#ifndef OVEN_H
  #define OVEN_H
  
  #include <QObject>
  #include <QTimer>

  #include <QTime>

  #include "define.h"

  class OvenInterface : public QObject
  {
      Q_OBJECT
  
  public:

      OvenInterface(QObject *parent = 0) : QObject(parent) {}

      virtual ~OvenInterface(){}
      virtual int currentTemp() = 0;
      virtual int currentHumidity() = 0;
      virtual int currentInterTemp() = 0;
      virtual bool door() = 0;
  
  signals:

      void doorOpened();
      void doorClosed();

  
  public slots:

      virtual void setMode(Define::Mode mode) = 0;

      virtual void setHumidity(int percentage) = 0;
      virtual void setTemp(int celsius) = 0;

      virtual void setTime(int secs) = 0;

      virtual void setInterTemp(int celsius) = 0;
      virtual void setFan(int rpm) = 0;
  
      virtual void startCooking() = 0;
      virtual void stopCooking() = 0;
      virtual void startPreheating() = 0;
      virtual void stopPreheating() = 0;
      virtual void startCooldown() = 0;
      virtual void stopCooldown() = 0;
      virtual void startHumidification() = 0;
      virtual void stopHumidification() = 0;
      virtual void startWashing() = 0;
      virtual void stopWashing() = 0;
  
      virtual void openDamper() = 0;
      virtual void closeDamper() = 0;
  };
  
  Q_DECLARE_INTERFACE(OvenInterface, "OvenInterface")
  
  class Oven : public QObject
  {
      Q_OBJECT

      explicit Oven(QObject *parent = 0);

      Define::Mode mode_;

      int humidity_;
      int temp_;
      int time_;
      bool interTempEnabled_ = false;
      int interTemp_;
      int fan_; // 1 ~ 5
      bool cooking_ = false;
      bool preheating_ = false;
      bool cooldown_ = false;
      bool damper_ = false; // true: open, false: close
      bool humidification_ = false;
      bool door_ = false; // true: open, false: close

  
      int currentHumidity_;
      int currentTemp_;
      int currentInterTemp_;

      bool isInterTempValid_;
      QTime interTempValidTime;
  
      bool damperRepeat;
      bool damperRepeatInfinitely;
      int damperRepeatRuntime;
      int damperRepeatDelay;
      int damperRepeatCount;
      QTimer damperRepeatRuntimeTimer;
      QTimer damperRepeatDelayTimer;
      bool damperRepeatPaused;
      bool damperRepeatPausedOnRuntime;
      int damperRepeatRemainingTime;
  
      bool humidificationRepeat;
      bool humidificationRepeatInfinitely;
      int humidificationRepeatRuntime;
      int humidificationRepeatDelay;
      int humidificationRepeatCount;
      QTimer humidificationRepeatRuntimeTimer;
      QTimer humidificationRepeatDelayTimer;
      bool humidificationRepeatPaused;
      bool humidificationRepeatPausedOnRuntime;
      int humidificationRepeatRemainingTime;

  
      bool paused_;
  
      QTimer cookingTimer;

      QTimer damperTimer;

      QTimer humidificationTimer;
      QTimer interTempTimer;
  
      OvenInterface *interface;

      static Oven *instance;

  public:

      static Oven *getInstance() {
          if (instance == 0)
              instance = new Oven();
  
          return instance;
      }

      Define::Mode mode() { return mode_; }

      int humidity() { return humidity_; }
      int temp() { return temp_; }
      int time();
      bool interTempEnabled() { return interTempEnabled_; }
      int interTemp() { return interTemp_; }
      int fan() { return fan_; }
      bool cooking() { return cooking_; }
      bool preheating() { return preheating_; }
      bool cooldown() { return cooldown_; }
      bool damper() { return damper_; }
      bool humidification() { return humidification_; }
      bool door() { return door_; }

      bool paused() { return paused_; }

      int currentTemp() { return currentTemp_; }
      int currentHumidity() { return currentHumidity_; }
      int currentInterTemp() { return currentInterTemp_; }

      bool isInterTempValid();

      int msecs();

      bool cookingStartable();
      bool preheatingStartable();
      bool cooldownStartable();
      bool humidificationStartable();
      bool damperOpenable();
  
  
      int maxTemp();
      int minTemp();
      int maxInterTemp();
      int minInterTemp();
      int maxFan();
      int minFan();
  
  signals:
      void changed(Oven *);
      void doorOpened();
  
  public slots:

      void setMode(Define::Mode mode);
      void setDefault(Define::Mode mode);

      void setHumidity(int percentage);
      void setTemp(int celsius);
      void setTime(int secs);
      void setInterTempEnabled(bool enabled);
      void setInterTemp(int celsius);
      void setFan(int speed);
  
      void stop();
      void startCooking();
      void stopCooking();
      void startPreheating();
      void stopPreheating();
      void startCooldown();
      void stopCooldown();

      void startHumidification(int secs = 600);

      void stopHumidification();

      void openDamper(int secs = 300);

      void closeDamper();

      void repeatHumidification(int runtime, int delay, int count = 0);
      void stopRepeatHumidification();
      void pauseRepeatHumidification();
      void resumeRepeatHumidification();
  
      void repeatDamper(int runtime, int delay, int count = 0);
      void stopRepeatDamper();
      void pauseRepeatDamper();
      void resumeRepeatDamper();

      void setCurrentHumidity(int percentage);
      void setCurrentTemp(int celsius);
      void setCurrentInterTemp(int celsius);

  
      void setInterface(OvenInterface *interface);
  
  private slots:

      bool setMode_(Define::Mode mode);

      bool setHumidity_(int percentage);
      bool setTemp_(int celsius);
      bool setInterTempEnabled_(bool enabled);
      bool setInterTemp_(int celsius);
      bool setFan_(int speed);

      void runRepeatHumidification();
      void idleRepeatHumidification();

      void runRepeatDamper();
      void idleRepeatDamper();

  
      void onDoorOpened();
      void onDoorClosed();
  };

  #endif // OVEN_H