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

  #include <QList>

  namespace Cook {
      enum CookType
      {
          Poultry,
          Meat,
          Fish,
          Desert,
          Vegetable,
          Bread,
          Etc
      };
  
      enum StepClass
      {
          InvalidClass,
          PreheatClass,
          DoorClass,
          CookClass
      };
  
      enum StepType
      {
          Invalid,
  
          Preheat,        // 예열
          PutThermometer, // 중심 온도계 삽입
          Load,           // 식재료 적재
          Cut,            // 자르기
          Pour,           // 물 붓기
  
          Bake,           // 베이킹
          Dry,            // 건조
          Ferment,        // 발효
          BlowSteam,      // 스팀 쏘이기
          CoolDown,       // 식히기
          Steam,          // 찌기
          Roast,          // 로스팅
          Boil,           // 끓이기
          Thicken,        // 걸쭉하게 만들기
          WarmUp,         // 데우기
          MakeCrispy,     // 바삭하게 만들기
          Finish,         // 피니싱
          Damp,           // 습윤하게 만들기
          Defer,          // 보류
          Grill,          // 그릴
          End,            // 종료
          Burn,           // 그을리기
          Fry,            // 기름에 볶기
          HeatUp,         // 온도 높이기
          Ripen,          // 숙성
          RipenKeep,      // 숙성 & 보존
          BoilSteadily,   // 뭉근하게 끓이기
          CookGratin,     // 그라탱 요리
          Brown,          // 브라우닝
          Simmer,         // 약한 불로 끓이기
          Moisten         // 촉촉하게
      };
  
      enum Mode {
          SteamMode, DryMode, CombiMode
      };
  
      struct Step {
          StepType type;
          Mode mode;
          int humidity;
          int temp;
      };
  
      enum Configuration {
          Brightness,
          Time,
          BurnDegree
      };
  
      StepClass classify(StepType type);
      QString name(StepType type);
      QString icon(CookType type);
      QString icon(StepType type);
  }
  
  class AbstractCookConfig
  {
  public:
      Cook::Configuration type();
      QString icon();
      QString overlayIcon();
      QString minLabel();
      QString maxLabel();
      virtual QString currentLabel();
  
      int count();
      int current();
      int standard();
  
      virtual int configureTime(int standardTime);
      virtual int configureInterTemp(int standardInterTemp);
      virtual Cook::Step configureStep(Cook::Step standardStep);
  
  public slots:
      void setCount(int value);
      void setCurrent(int value);
      void setStandard(int value);
  
  protected:
      Cook::Configuration type_;
      QString icon_;
      QString overayIcon_;
      QString minLabel_;
      QString maxLabel_;
      QString currentLabel_;
  
      int standard_;
      int current_;
      int count_;
  };
  
  class AbstractCook

  {

  public:

      AbstractCook() { for (int idx = 0; idx < 5; idx++) configurations[idx] = NULL; }
      ~AbstractCook();
  
      Cook::CookType type();
      QString name();
      int time();
      bool interTempEnabled();

      void setInterTempEnabled(bool enabled);

      int interTemp();
  
      Cook::Step currentStep();
      Cook::Step step(int index);

      int currentStepIndex();
      void setCurrentStepIndex(int index);
  
      int stepCount();
  
      AbstractCookConfig *configurations[5];
  
  protected:
      Cook::CookType type_;
      QString name_;
      int time_;
      bool interTempEnabled_;
      int interTemp_;
      int currentStep_;
      int stepCount_;
      Cook::Step stepList[10];
  };
  
  class BrightnessConfig : public AbstractCookConfig
  {
  public:
      BrightnessConfig();
      Cook::Step configureStep(Cook::Step standardStep);
  };
  
  class TimeConfig : public AbstractCookConfig
  {
  public:
      TimeConfig();
      int configureTime(int standardTime);
  };
  
  class BurnDegreeConfig : public AbstractCookConfig
  {
  public:
      BurnDegreeConfig();
      Cook::Step configureStep(Cook::Step standardStep);
      int configureInterTemp(int standardInterTemp);
  };
  
  class FriedRice : public AbstractCook
  {
  public:
      FriedRice();
  };
  
  class ChickenCook : public AbstractCook
  {
  public:
      ChickenCook();
  };
  
  class MeatPie : public AbstractCook
  {
  public:
      MeatPie();
  };
  
  class Croissant : public AbstractCook
  {
  public:
      Croissant();

  };
  
  #endif // COOK_H