#include "Http/PrepareAnswer.h"

#include <string>
#include <iostream>
#include <version.h>

Incart::CablesDatabase::PrepareAnswer::PrepareAnswer()
{
    QString cablesXmlPath = QCoreApplication::applicationDirPath() + "/CablesV2.xml";
    std::string cablesXmlPathConverted = cablesXmlPath.toStdString();
    m_cablesXml.LoadFile(cablesXmlPathConverted.c_str());
    tinyxml2::XMLElement* cableListElement = m_cablesXml.RootElement(); // <Cables>
    if (cableListElement != nullptr)
    {
      for (tinyxml2::XMLElement* cableElement = cableListElement->FirstChildElement("Cable"); cableElement; cableElement = cableElement->NextSiblingElement("Cable"))
      {
        tinyxml2::XMLElement* typeElement = cableElement->FirstChildElement("Type");
        if (typeElement == nullptr) {
          continue;
        }
        tinyxml2::XMLElement* nameElement = cableElement->FirstChildElement("FullName");
        if (nameElement == nullptr) {
          continue;
        }
        tinyxml2::XMLElement* vinElement = cableElement->FirstChildElement("Vin");
        if (vinElement == nullptr) {
          continue;
        }
        tinyxml2::XMLElement* packElement = cableElement->FirstChildElement("Pack");
        tinyxml2::XMLElement* seriesElement = cableElement->FirstChildElement("Serie");

        uint8_t cableType = static_cast<uint8_t>(atoi(typeElement->GetText()));
        std::string cableName = nameElement->GetText();
        uint8_t cablePack = static_cast<uint8_t>(atoi(packElement == nullptr ? "" : packElement->GetText()));
        std::string cableSeries = seriesElement == nullptr ? "" : seriesElement->GetText();
        std::string cableVin = vinElement->GetText();

        m_cableTypes.insert({cableType, CableTypeInfo{cableType, cableName, cablePack, cableSeries, cableVin} });
        m_actualCables.push_back(cableType);
      }
    }

    // распознаваемые значения path
    m_exeGet[""]        = new exeGetIndex(this);
    m_exeGet["__err"]   = new exeGet(this);
    m_exeGet["__file"]  = new exeGetFile(this);
    m_exeGet["getDir"]  = new exeGetDir(this);
    m_exeGet["ping"]  = new exePing(this);
    m_exeGet["getCableByType"]  = new exeGetCableByType(this);
    m_exeGet["getCablesByMode"]  = new exeGetCablesByMode(this);
    m_exeGet["getLastNumberByType"]  = new exeGetLastNumberByType(this);
    m_exeGet["addCable"]  = new exeAddCable(this);
    m_exeGet["addPerson"]  = new exeAddPerson(this);
    m_exeGet["getPeopleList"]  = new exeGetPeopleList(this);
    m_exeGet["getReport"]  = new exeGetReport(this);
    m_exeGet["getTypeBySerial"] = new exeGetTypeBySerial(this);
    m_exeGet["getAllCableTypes"] = new exeGetAllCableTypes(this);
    m_exeGet["isExistNumber"] = new exeIsExistNumber(this);
    m_exeGet["getProgramVersion"] = new ProgramVersionWebApiCommand(this);
    m_ext["html"]   = "Content-Type: text/html; charset=utf8;";
    m_ext["json"]   = "Content-Type: text/json; charset=utf8;";
    m_ext["js"]     = "Content-Type: text/javascript; charset=utf8;";
    m_ext["css"]    = "Content-Type: text/css; charset=utf8;";
    m_ext["txt"]    = "Content-Type: text/plain; charset=utf8";
    m_ext["map"]    = "Content-Type: application/x-navimap";
    m_ext["svg"]    = "Content-Type: image/svg+xml";
}

Incart::CablesDatabase::Response* Incart::CablesDatabase::PrepareAnswer::exe(QByteArray query)
{
    if (!db->hasValidDatabase())
    {
        jsonRet(QJsonDocument(errDatabaseExistJson).toJson());
        return &m_resp;
    }
    m_query.exe(query);

    QString method = m_query.getMethod();
    QString path = m_query.getPath();
    QString extension = m_query.getExtension();
    //qDebug() << path << QDateTime::currentDateTime();
    if(method=="GET")
    {
        if(m_exeGet.contains(path))              { m_exeGet[path]->exe(); }
        else if(m_ext.contains(extension))       { m_exeGet["__file"]->exe(); }
        else                                     { m_exeGet["__file"]->exe(); }
    }
    else
    {
        qDebug() << "error";
        m_exeGet["__err"]->exe();
    }
    //delete db;
    return &m_resp;
}
//-----------------------------------------------------------------------------
void Incart::CablesDatabase::PrepareAnswer::htmlRet(QByteArray body)
{
    m_resp.begin("200 OK");
    m_resp.insert("Access-Control-Allow-Origin:*");
    m_resp.insert("Content-Type: text/html; charset=utf8");
    m_resp.end(body);
}

void Incart::CablesDatabase::PrepareAnswer::jsonRet(QByteArray body)
{
    m_resp.begin("200 OK");
    m_resp.insert("Access-Control-Allow-Origin:*");
    m_resp.insert("Content-Type: text/json");
    m_resp.end(body);
}

void Incart::CablesDatabase::PrepareAnswer::txtRet(QByteArray body)
{
    m_resp.begin("200 OK");
    m_resp.insert("Access-Control-Allow-Origin:*");
    m_resp.insert("Content-Type: text/plain");
    m_resp.end(body);
}

void Incart::CablesDatabase::PrepareAnswer::extRet(QByteArray body)
{
    m_resp.begin("200 OK");
    m_resp.insert("Access-Control-Allow-Origin:*");
    QString ext = m_query.getExtension();
    if( m_ext.contains(ext) )   m_resp.insert(m_ext[ext]);
        else                    m_resp.insert(m_ext["txt"]);
    m_resp.end(body);
}


void Incart::CablesDatabase::PrepareAnswer::downloadRet(QFile* f)
{
    f->open(QIODevice::ReadOnly);
    m_resp.begin("200");
    m_resp.insert("Access-Control-Allow-Origin:*");
    m_resp.insert("Access-Control-Expose-Headers: Content-Disposition");
    m_resp.insert("Content-Type: application/octet-stream");
    m_resp.insert("Content-Size: " + QString::number(f->size()));
    m_resp.insert("Content-Disposition: attachment; filename=" + f->fileName());
    m_resp.insert("Accept-Ranges: bytes");
    qint64 bytesRead = 64000;
    m_resp.end(f->read(64000));
    while(bytesRead < f->size()){
        f->seek(bytesRead);
        m_resp.add(f->read(64000));
        bytesRead+=64000;
    }
    f->close();
}

void Incart::CablesDatabase::PrepareAnswer::errRet(QString err)
{
    m_resp.begin("400");
    m_resp.insert("Access-Control-Allow-Origin:*");
    m_resp.insert("Content-Type: text/html; charset=utf8");
    m_resp.end(err);
}


//-----------------------------------------------------------------------------
void Incart::CablesDatabase::exeGet::exe()
{
    m_ans->errRet("501 Not Implemented");
}

void Incart::CablesDatabase::exePing::exe()
{
    m_ans->extRet("200 OK");
}

void Incart::CablesDatabase::exeGetIndex::exe()
{
    QFile file("index.html");
    if ( file.open(QIODevice::ReadOnly))
    {
        m_ans->htmlRet(file.readAll());
        file.close();
    }
    else
    {
        qDebug() << "file not found " << file.fileName();
        m_ans->errRet("404 Not Found");
    }
}

void Incart::CablesDatabase::exeGetFile::exe()
{
    QFile file(m_query->getPath());
    if ( file.open(QIODevice::ReadOnly))
    {
        m_ans->extRet(file.readAll());
        file.close();
    }
    else
    {
        qDebug() << "file not found " << file.fileName();
        m_ans->errRet("404 Not Found");
    }
}

void Incart::CablesDatabase::exeGetDir::exe()
{
    QDir dir;
    dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
    dir.setSorting(QDir::Size | QDir::Reversed);
    QFileInfoList list = dir.entryInfoList();
    QJsonArray array;
    for (int i = 0; i < list.size(); i++)
    {
        QFileInfo fileInfo = list.at(i);
        QString filename = fileInfo.fileName();
        QString extension = filename.split(".").last();
            QJsonObject obj = {{"filename", filename}};
            array.append(obj);
    }
    QJsonDocument doc(array);
    m_ans->jsonRet(doc.toJson());
}

void Incart::CablesDatabase::exeGetCableByType::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if (hash.contains("type"))
    {
        uint8_t type = static_cast<uint8_t>(hash.find("type")->toInt());
        auto& cableTypes = m_ans->getCableTypes();
        auto it = cableTypes.find(type);
        if (it == cableTypes.end())
        {
          m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
          return;
        }
        QJsonObject out = m_ans->cableToJson(it->second.pack, it->second.type, QString::fromStdString(it->second.name), QString::fromStdString(it->second.series));
        m_ans->jsonRet(QJsonDocument(out).toJson());
    }
    else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }
}

void Incart::CablesDatabase::exeGetCablesByMode::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if(hash.contains("mode") && hash.contains("series"))
    {
        uint8_t mode = static_cast<uint8_t>(hash.find("mode")->toInt());
        std::string series = hash.value("series").toStdString();

        std::vector<CableTypeInfo> cableTypes = m_ans->getActualCableTypes();
        QJsonArray out;
        for (auto it = cableTypes.begin(); it != cableTypes.end(); ++it)
        {
          if ((it->series.compare(series) == 0) && (it->pack == mode))
          {
            out.append(m_ans->cableToJson(mode, it->type, QString::fromStdString(it->name), QString::fromStdString(series)));
          }
        }
        m_ans->jsonRet(QJsonDocument(out).toJson());
    } else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }
}

void Incart::CablesDatabase::exeGetTypeBySerial::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if (hash.contains("vin"))
    {
        std::string vin = hash.value("vin").toStdString();
        auto& cableTypes = m_ans->getCableTypes();
        for (auto& it: cableTypes)
        {
            if (it.second.vin.compare(vin) == 0)
            {
              QJsonObject out{{"type", static_cast<int32_t>(it.second.type) }};
              m_ans->jsonRet(QJsonDocument(out).toJson());
              return;
            }
        }
    }
    m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
}

void Incart::CablesDatabase::exeGetAllCableTypes::exe()
{
    std::vector<CableTypeInfo> cableTypes = m_ans->getActualCableTypes();
    QJsonArray out;
    for (auto it = cableTypes.begin(); it != cableTypes.end(); ++it)
    {
        out.append(QJsonObject({
          {"Type", it->type},
          {"Vin", QString::fromStdString(it->vin)},
        }));
    }
    m_ans->jsonRet(QJsonDocument(out).toJson());
}

void Incart::CablesDatabase::exeIsExistNumber::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if (hash.contains("type") && hash.contains("number"))
    {
        qint8 type = hash.find("type")->toInt();
        qint32 number = hash.find("number")->toInt();
        bool isExist = m_ans->db->isExistNumber(type, number);
        QJsonObject out({{"Result", isExist}});
        m_ans->jsonRet(QJsonDocument(out).toJson());
    } else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }

}

void Incart::CablesDatabase::exeGetLastNumberByType::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if(hash.contains("type"))
    {
        qint8 type = hash.find("type")->toInt();
        qint32 num = m_ans->db->getLastNumberByType(type);
        QJsonObject out({{"Result", num}});
        m_ans->jsonRet(QJsonDocument(out).toJson());
    } else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }
}

void Incart::CablesDatabase::exeAddCable::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if(hash.contains("type") && hash.contains("number"))
    {
        qint8 type = hash.find("type")->toInt();
        qint32 number = hash.find("number")->toInt();
        bool success;
        if(hash.contains("numName") && hash.contains("prodName") && hash.contains("prodDate") && hash.contains("numDate"))
        {
            int numName = hash.find("numName")->toInt();
            int prodName = hash.find("prodName")->toInt();
            QString prodDate = hash.value("prodDate");
            QString numDate = hash.value("numDate");
            success = m_ans->db->addCable(type, number, numName, prodName, prodDate, numDate);
        } else
        {
            success = m_ans->db->addCable(type);
        }
        QJsonObject out({{"Result", success}});
        m_ans->jsonRet(QJsonDocument(out).toJson());
    } else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }
}

void Incart::CablesDatabase::exeAddPerson::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if(hash.contains("fio") && hash.contains("info"))
    {
        QString fio = hash.value("fio");
        QString info = hash.value("info");
        bool success = m_ans->db->addPerson(fio, info);
        QJsonObject out({{"Result", success}});
        m_ans->jsonRet(QJsonDocument(out).toJson());
    } else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }
}

void Incart::CablesDatabase::exeGetPeopleList::exe()
{
    QJsonObject outArr = m_ans->db->getPeopleList();
    m_ans->jsonRet(QJsonDocument(outArr).toJson());
}

void Incart::CablesDatabase::exeGetReport::exe()
{
    QMultiHash<QString, QString>& hash = m_query->getArgs();
    if(hash.contains("date"))
    {
        QString date = hash.value("date");
        m_ans->db->getReport(date);
        QFile out("report.csv");
        m_ans->downloadRet(&out);
        out.remove();
    } else
    {
        m_ans->jsonRet(QJsonDocument(m_ans->errJson).toJson());
    }
}

void Incart::CablesDatabase::ProgramVersionWebApiCommand::exe()
{
  QString programVersion = APP_VERSION;
  QByteArray answer = programVersion.toUtf8();
  m_ans->txtRet(answer);
}