#pragma once

#include "Sql/DBHelper.h"
#include "ParsingQuery.h"
#include <qglobal.h>
#include <QDebug>
#include <QDir>
#include <QFile>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QString>
#include <QMap>
#include <QVector>
#include <QUrl>
#include <vector>
#include <unordered_map>
#include <string>
#include <tinyxml2.h>

namespace Incart::CablesDatabase
{

struct Response
{
    QByteArray  res;
    QString     hdr;
    bool        flg;

    void insert(QString str)
    {
        hdr += str + "\r\n";
    }

    void begin(QString code)
    {
        res.clear();
        hdr = "HTTP/1.1 " + code + "\r\n";
        flg = true;
    }

    void end(QString body)
    {
        hdr += "\r\n";
        res.append(hdr.toUtf8());
        res.append(body.toUtf8());
    }

    void add(QByteArray arr){
        res.append(arr);
    }

    void end(QByteArray body)
    {
        hdr += "\r\n";
        res.append(hdr.toUtf8());
        res.append(body);
    }

};

struct CableTypeInfo
{
  uint8_t type;
  std::string name;
  uint8_t pack;
  std::string series;
  std::string vin;
};

class exeGet;
class makeCmdDev;
class PrepareAnswer
{
public:
    PrepareAnswer();
    Response* exe(QByteArray);
    DBHelper* db = new DBHelper();
    Response*       getResponse()   { return &m_resp; }
    ParsingQuery*   getQuery()      { return &m_query; }
    makeCmdDev*     getCmdDev()     { return m_makeCmdDev; }

protected:
    ParsingQuery    m_query;
    Response        m_resp;
    makeCmdDev*     m_makeCmdDev;

    QMap<QString,exeGet*> m_exeGet;
    QMap<QString,QString> m_ext;
    tinyxml2::XMLDocument m_cablesXml;
    std::unordered_map<uint8_t, CableTypeInfo> m_cableTypes; // all cabel types that can be numerated
    std::vector<uint8_t> m_actualCables; // types of cables currently in production

public:
    void htmlRet(QByteArray body);
    void jsonRet(QByteArray body);
    void txtRet(QByteArray body);
    void extRet(QByteArray body);
    void errRet(QString err);
    void downloadRet(QFile* file);

    QJsonObject errJson = {{"errors", QJsonObject({{"id", QJsonArray({"Wrong arguments!"})}})}, {"status", 400}};

    QJsonObject errDatabaseExistJson = {{"errors", QJsonObject({{"id", QJsonArray({"Database(" + db->getDatabasePath() +") is not exist!"})}})}, {"status", 500}};

    QJsonObject badIdJson(QString id)
    {
        return {{"errors", QJsonObject({{"id", QJsonArray({"The value '" + id + "' is not valid."})}})}, {"status", 400}};
    }

    QJsonObject cableToJson(uint8_t mode, uint8_t type, QString name, QString serie)
    {
        return QJsonObject({
                           {"Mode", static_cast<int32_t>(mode)},
                           {"Type", static_cast<int32_t>(type)},
                           {"Name", name},
                           {"Serie", serie}
                           });
    }

    std::unordered_map<uint8_t, CableTypeInfo>& getCableTypes() { return m_cableTypes; }

    std::vector<CableTypeInfo> getActualCableTypes()
    {
      std::vector<CableTypeInfo> result;
      for (auto actualIter = m_actualCables.begin(); actualIter != m_actualCables.end(); ++actualIter)
      {
        auto typeInfoIter = m_cableTypes.find(*actualIter);
        if (typeInfoIter != m_cableTypes.end())
        {
          result.push_back(CableTypeInfo{typeInfoIter->second});
        }
      }
      return result;
    }
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class exeGet
{
public:
    exeGet(PrepareAnswer* ans) : m_ans(ans),m_query(ans->getQuery()), m_rsp(ans->getResponse()) {}
    virtual ~exeGet() {}
    virtual void exe();

protected:
    PrepareAnswer*   m_ans;
    ParsingQuery*   m_query;
    Response*       m_rsp;
};

class exeGetIndex : public exeGet
{
public:
    exeGetIndex(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetFile : public exeGet
{
public:
    exeGetFile(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exePing : public exeGet
{
public:
    exePing(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetDir : public exeGet
{
public:
    exeGetDir(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetCableByType : public exeGet
{
public:
    exeGetCableByType(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetCablesByMode : public exeGet
{
public:
    exeGetCablesByMode(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetLastNumberByType : public exeGet
{
public:
    exeGetLastNumberByType(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetTypeBySerial : public exeGet
{
public:
    exeGetTypeBySerial(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetAllCableTypes : public exeGet
{
public:
    exeGetAllCableTypes(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeIsExistNumber : public exeGet
{
public:
    exeIsExistNumber(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};


class exeAddCable : public exeGet
{
public:
    exeAddCable(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeAddPerson : public exeGet
{
public:
    exeAddPerson(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetPeopleList : public exeGet
{
public:
    exeGetPeopleList(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class exeGetReport : public exeGet
{
public:
    exeGetReport(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

class ProgramVersionWebApiCommand : public exeGet
{
public:
    ProgramVersionWebApiCommand(PrepareAnswer* ans) : exeGet(ans) {}
    void exe() override;
};

//-----------------------------------------------------------------------------
} // namespace Incart::CablesDatabase