#include "cook.h"

  #include <QErrorMessage>

  static QErrorMessage *errorDialog = NULL;
  static void showError(QString errorMessage)

  {

      if (errorDialog == NULL)
      {
          errorDialog = new QErrorMessage;
          errorDialog->setWindowModality(Qt::ApplicationModal);

          errorDialog->setGeometry(QRect(0, 511, 1080, 511));

      }

      errorDialog->showMessage(errorMessage);
      errorDialog->exec();

  }

  Cook::Cook()
      : type(Define::InvalidCookType),
        isInitialized_(false), isLoaded_(false), isCoreTempValid_(false),
        time_(0), coreTemp_(0)

  {

      for (int i = 0; i < 5; i++)
          configs[i].type = Define::InvalidConfig;

  }

  Cook::Cook(Define::CookType type, QString root, QString name)
      : Cook()

  {

      if (!root.endsWith("/"))
          root += "/";

      this->type = type;
      this->root = root;
      this->name = name;

      initialize();

  }

  void Cook::initialize()

  {

      if (type == Define::InvalidCookType || root.isEmpty() || name.isEmpty())
          return;

      QFile file(root + "config.csv");
      if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
      {
          showError("File not found: " + file.fileName());
          return;
      }

      int lineCount = 0;
      int configIndex = 0;
      while (!file.atEnd())
      {
          if (configIndex == 5)
              break;

          lineCount++;

          QString line = QString::fromUtf8(file.readLine()).trimmed();
          if (line.isEmpty())
              continue;

          if (line.startsWith("use"))
              continue;

          QString errorMessage = QString("%3: %1, line %2").arg(file.fileName()).arg(lineCount);

          QString use = line.section(',', 0, 0).trimmed();
          if (use.isEmpty())
          {
              showError(errorMessage.arg("Use column must be filled"));
              file.close();
              return;
          }

          if (use == "yes")
          {
              CookConfig config;
  
              config.type = Define::identifyConfigType(line.section(',', 1, 1).trimmed());
              if (config.type == Define::InvalidConfig)
              {
                  showError(errorMessage.arg("Invalid configuration type"));
                  file.close();
                  return;
              }
  
              bool ok;
              config.maximum = line.section(',', 2, 2).trimmed().toInt(&ok);
              if (!ok)
              {
                  showError(errorMessage.arg("Invalid count"));
                  file.close();
                  return;
              }
  
              config.current = line.section(',', 3, 3).trimmed().toInt(&ok);
              if (!ok)
              {
                  showError(errorMessage.arg("Invalid default"));
                  file.close();
                  return;
              }
  
              configs[configIndex++] = config;
          }
          else
              configs[configIndex++] = CookConfig { Define::ConfigNotUsed, 0, 0 };

      }

      file.close();

      for (int i = configIndex; i < 5; i++)
          configs[configIndex++] = CookConfig { Define::ConfigNotUsed, 0, 0 };

      isInitialized_ = true;

  }

  void Cook::setConfig(int first, int second, int third, int fourth, int fifth)

  {

      if (!isInitialized())
          return;

      int currents[5] = { first, second, third, fourth, fifth };
      for (int i = 0; i < 5; i++)
      {
          if (configs[i].type == Define::ConfigNotUsed)
              continue;

          if (configs[i].current != currents[i])
          {
              configs[i].current = currents[i];
              isLoaded_ = false;
          }
      }

  }

  void Cook::load()

  {

      if (!isInitialized())
          return;

      QString selection;
      for (int i = 0; i < 5; i++)
      {
          if (configs[i].type == Define::ConfigNotUsed)
              continue;

          selection += QString::number(configs[i].current);
      }

      QFile dataFile(root + "data." + selection + ".csv");
      if (!dataFile.open(QIODevice::ReadOnly | QIODevice::Text))
      {
          showError("File not found: " + dataFile.fileName());
          return;
      }

      steps.clear();

      int lineCount = 0;
      while (!dataFile.atEnd())
      {
          lineCount++;

          QString line = QString::fromUtf8(dataFile.readLine()).trimmed();
          if (line.isEmpty())
              continue;

          if (line.startsWith("type"))
              continue;

          QString errorMessage = QString("%3: %1, line %2").arg(dataFile.fileName()).arg(lineCount);

          CookStep step;
          bzero(&step, sizeof(step));

          step.type = Define::identifyStepType(line.section(',', 0, 0).trimmed());
          switch (Define::classify(step.type))
          {
          case Define::InvalidClass:
              showError(errorMessage.arg("Invalid type"));
              continue;
          case Define::DoorClass:
              steps.append(step);
              continue;
          default:
              break;
          }

          step.mode = Define::identifyMode(line.section(',', 1, 1).trimmed());
          if (step.mode == Define::InvalidMode)
          {
              showError(errorMessage.arg("Invalid mode"));
              continue;
          }

          bool ok;

          step.humidity = line.section(',', 3, 3).trimmed().toInt(&ok);
          if (!ok || step.humidity < 0 || step.humidity > 100)
          {
              showError(errorMessage.arg("Invalid humidity"));
              continue;
          }

          step.temp = line.section(',', 4, 4).trimmed().toInt(&ok);
          if (!ok || step.temp < 30 || step.temp > 300)
          {
              showError(errorMessage.arg("Invalid temperature"));
              continue;
          }

          step.fan = line.section(',', 6, 6).trimmed().toInt(&ok);
          if (!ok || step.fan < 1 || step.fan > 5)
          {
              showError(errorMessage.arg("Invalid fan level"));
              continue;
          }

          if (step.type == Define::Preheat)
          {
              steps.append(step);
              continue;
          }

          step.time = line.section(',', 2, 2).trimmed().toInt(&ok);
          if (!ok || step.time <= 0)
          {
              showError(errorMessage.arg("Invalid time"));
              continue;
          }

          int tInt = line.section(',', 5, 5).trimmed().toInt(&ok);
          if (ok)
          {
              if (tInt < 0 || tInt > 100)
              {
                  showError(errorMessage.arg("Invalid coreTemperature"));
                  continue;
              }

              step.coreTemp = tInt;
          }

          tInt = line.section(',', 7, 7).trimmed().toInt(&ok);
          if (ok)
          {
              if (tInt < 0)
              {
                  showError(errorMessage.arg("Invalid damper"));
                  continue;
              }
  
              step.dehumidification = tInt;
  
              tInt = line.section(',', 9, 9).trimmed().toInt(&ok);
              if (ok)
              {
                  if (tInt < 0)
                  {
                      showError(errorMessage.arg("Invalid damperRepeat"));
                      continue;
                  }
  
                  step.dehumidificationRepeatDelay = tInt;
  
                  tInt = line.section(',', 11, 11).trimmed().toInt(&ok);
                  if (ok)
                  {
                      if (tInt < 0)
                      {
                          showError(errorMessage.arg("Invalid damperRepeatCount"));
                          continue;
                      }
  
                      step.dehumidificationRepeatCount = tInt;
                  }
              }
          }

          tInt = line.section(',', 8, 8).trimmed().toInt(&ok);
          if (ok)
          {
              if (tInt < 0)
              {
                  showError(errorMessage.arg("Invalid sideNozzle"));
                  continue;
              }
  
              step.humidification = tInt;
  
              tInt = line.section(',', 10, 10).trimmed().toInt(&ok);
              if (ok)
              {
                  if (tInt < 0)
                  {
                      showError(errorMessage.arg("Invalid sideNozzleRepeat"));
                      continue;
                  }
  
                  step.humidificationRepeatDelay = tInt;
  
                  tInt = line.section(',', 12, 12).trimmed().toInt(&ok);
                  if (ok)
                  {
                      if (tInt < 0)
                      {
                          showError(errorMessage.arg("Invalid sideNozzleRepeatCount"));
                          continue;
                      }
  
                      step.humidificationRepeatCount = tInt;
                  }
              }
          }

          steps.append(step);
      }

      dataFile.close();

      QFile processFile(root + "process.csv");
      if (!processFile.open(QIODevice::ReadOnly | QIODevice::Text))

      {

          showError("File not found: " + processFile.fileName());
          return;

      }

      lineCount = 0;
      while (!processFile.atEnd())

      {

          lineCount++;
  
          QString line = QString::fromUtf8(processFile.readLine()).trimmed();
          if (line.isEmpty())
              continue;
  
          if (line.startsWith("type"))
              continue;
  
          QString errorMessage = QString("%3: %1, line %2").arg(processFile.fileName()).arg(lineCount);
  
          Define::Process process = Define::identifyProcess(line);
          if (process == Define::InvalidProcess)
          {
              showError(errorMessage.arg("Invalid type"));
              continue;
          }
  
          processes.append(process);

      }

      isLoaded_ = true;
  
      isCoreTempValid_ = false;
      time_ = 0;
      coreTemp_ = 0;
      foreach (CookStep s, steps)

      {

          if (s.coreTemp)
          {
              isCoreTempValid_ = true;
              coreTemp_ = s.coreTemp;
          }
  
          time_ += s.time;

      }
  }

  bool Cook::isCoreTempValid()

  {

      if (!isLoaded())
          load();

      return isCoreTempValid_;

  }

  int Cook::time()

  {

      if (!isLoaded())
          load();
  
      return time_;

  }

  int Cook::coreTemp()

  {

      if (!isLoaded())
          load();
  
      return coreTemp_;

  }