#include "static_pvsan_import.h"

#include <QFile>
#include <QTextStream>
#include <QDir>
#include <QSet>
#include <ngltools/ngltools_filesystem.h>
#include <ngldb/dbtransaction.h>
#include <ngldb/nsqlquery.h>

namespace ProjectDataManagement {

PvSanImport::PvSanImport(const std::shared_ptr<DatabaseInterface> &db,
                         NGL::INGLLogger &logger):
  m_version(QStringLiteral("-")),
  m_db(db),
  m_logger(logger)
{
  publishDataPvSan();
}

bool PvSanImport::publishDataPvSan()
{

  QVector<QString> procedures;
  QVector<QString> injuries;
  QVector<QString> material;
  QVector<QString> kind;
  QVector<QString> place1;
  QVector<QString> place2;

  //b->removePdmTranslation()
  if (!readFile(procedures, material, injuries, kind, place1, place2))
  {
    ERROR_LOG(m_logger) << "Can't read pvsan file";
    return false;
  }

  if(!addProcedures(procedures))
    return false;

  if(!addMaterial(material))
    return false;

  if(!addInjuryPlaces(kind, place1, place2))
    return false;

  if(!addInjuries(injuries))
    return false;

// X    X   A    A    B    B    C    C   D    D     E    E    M    M    0    0
//0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
//0000 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
  return true;
}

qint64 PvSanImport::getCode(const QString &type, int typeId)
{
  qint64 check = 1ULL;

  qint64 multiplayer = 1ULL;

  switch (type.at(0).unicode())
  {
  case 'x':
    multiplayer = multiplayer<<(55 + typeId);
    break;
  case 'A':
    multiplayer = multiplayer<<(47 + typeId);
    break;
  case 'B':
    multiplayer = multiplayer<<(39+ typeId);
    break;
  case 'C':
    multiplayer = multiplayer<<(31+ typeId);
    break;
  case 'D':
    multiplayer = multiplayer<<(23+ typeId);
    break;
  case 'E':
    multiplayer = multiplayer<<(15+ typeId);
    break;
  case 'M':
    multiplayer = multiplayer<<(7+ typeId);
    break;
  default:
    multiplayer = typeId;
    break;

  };
  check = multiplayer;
  return check;
}

bool PvSanImport::readFile(QVector<QString> &procedures, QVector<QString> &material,
                           QVector<QString> &injuries, QVector<QString> &kind,
                           QVector<QString> &place1, QVector<QString> &place2 )
{
  QString vbkFile = NGL::findFile(NGL::FileType::ConfigFile, QStringLiteral("vbk.csv"));
  QFile csvFile(vbkFile);
  DEBUG_LOG(m_logger) << "Start reading File " << vbkFile;

  if (!csvFile.exists())
    return false;
  if(!csvFile.open(QIODevice::ReadOnly))
    return false;
  DEBUG_LOG(m_logger) << "Opened File";

  bool skip = true;
  QTextStream in(&csvFile);
  in.setCodec("latin1");

  //version
  while (!in.atEnd())
  {
    QString line = in.readLine();
    if (!line.startsWith(QStringLiteral("Version")))
      continue;

   // ERROR_LOG(m_logger) << line;
    QStringList versionSplit = line.split(QStringLiteral(";"));
    if (versionSplit.size() > 1)
      m_version = versionSplit.at(1);
    break;
  }
  skip = true;

  //injuries
  while (!in.atEnd())
  {
    QString line = in.readLine();
    if (skip && !line.startsWith(QStringLiteral("VBA-Index")))
      continue;
    else if (skip)
    {
      //read one more line
      line = in.readLine();
      skip = false;
    }

    //now we read all lines until the end
    if (!line.isEmpty())
      injuries.append(line);
    else
      break;
  }
  skip = true;
  in.seek(0);

  //Material
  while (!in.atEnd())
  {
    const QString line = in.readLine();
    if (skip && !line.startsWith(QStringLiteral("sanmat")))
      continue;
    else if (skip)
    {
      //read one more line
      in.readLine();
      skip = false;
      continue;
    }
    //ERROR_LOG(m_logger) << line;

    //now we read all lines until the end
    if (!line.isEmpty())
      material.append(line);
    else
      break;
  }
  skip = true;
  in.seek(0);

  //procedures
  while (!in.atEnd())
  {
    const QString line = in.readLine();
    if (skip && !line.startsWith(QStringLiteral("massnahmen.csv")))
      continue;
    else if (skip)
    {
      //read one more line
      in.readLine();
      skip = false;
      continue;
    }

    //now we read all lines until the end
    if (!line.isEmpty())
      procedures.append(line);
    else
      break;
  }

  skip = true;
  in.seek(0);

  //kind
  while (!in.atEnd())
  {
    const QString line = in.readLine();
    if (skip && !line.startsWith(QStringLiteral("verwundungstyp")))
      continue;
    else if (skip)
    {
      //read one more line
      in.readLine();
      skip = false;
      continue;
    }

    //now we read all lines until the end
    if (!line.isEmpty())
      kind.append(line);
    else
      break;
  }
  skip = true;
  in.seek(0);

  //palce1
  while (!in.atEnd())
  {
    const QString line = in.readLine();
    if (skip && !line.startsWith(QStringLiteral("ort1")))
      continue;
    else if (skip)
    {
      //read one more line
      in.readLine();
      skip = false;
      continue;
    }

    //now we read all lines until the end
    if (!line.isEmpty())
      place1.append(line);
    else
      break;
  }
  skip = true;
  in.seek(0);

  //place2
  while (!in.atEnd())
  {
    const QString line = in.readLine();
    if (skip && !line.startsWith(QStringLiteral("ort2")))
      continue;
    else if (skip)
    {
      //read one more line
      in.readLine();
      skip = false;
      continue;
    }

    //now we read all lines until the end
    if (!line.isEmpty())
      place2.append(line);
    else
      break;
  }

  csvFile.close();

//  ERROR_LOG(m_logger) << "read " << procedures.size() << " procedures from file";
//  ERROR_LOG(m_logger) << "read " << material.size() << " materials from file";
//  ERROR_LOG(m_logger) << "read " << injuries.size() << " injuries from file";
//  ERROR_LOG(m_logger) << "read " << kind.size() << " kinds from file";
//  ERROR_LOG(m_logger) << "read " << place1.size() << " place1 from file";
//  ERROR_LOG(m_logger) << "read " << place2.size() << " place2 from file";


  return true;
}

bool PvSanImport::addProcedures(const QVector<QString> &procedures)
{
  if(procedures.isEmpty())
    return false;

  //check for DatabaseEntry with ID 1 and it's version
  Database::PdmSanitationProcedures procTemp;

  if (m_db->selectPdmSanitationProcedures(1, procTemp) && procTemp.version == m_version)
    return true;

  QString myContext=QStringLiteral("SanitationProcedure");
  //remove from DB
  m_db->truncatePdmSanitationProcedures();

  QVector<Database::PdmTranslation> translations;
  m_db->select(translations);
  QSet<quint64> idsToRemove;
  for (const auto &tr : qAsConst(translations))
  {
    if (tr.context == myContext)
      idsToRemove.insert(tr.id);
  }

  for (quint64 id : idsToRemove )
  {
    m_db->removePdmTranslation(id);
  }

  //insert into db
  Database::PdmSanitationProcedures pros;
  pros.id= 0;
  pros.type = QStringLiteral("-");
  pros.name = QStringLiteral("Keine");
  pros.typeId = 0;
  pros.longName = QStringLiteral("Keine");
  pros.dataCode = 0;

  m_db->insert(pros);


  Database::PdmTranslation trans;
  trans.key = pros.name;
  trans.disambiguation = QStringLiteral("name");
  trans.context = myContext;
  trans.translation = QStringLiteral("None");
  trans.isoCode = QStringLiteral("en_GB");
  m_db->insert(trans);
  trans.id = 0;
  trans.isoCode = QStringLiteral("en_US");
  m_db->insert(trans);
  trans.id = 0;
  trans.translation = pros.name;
  trans.isoCode = QStringLiteral("de_DE");
  m_db->insert(trans);

  for (const QString &entry: procedures)
  {

   QStringList measure = entry.split(QStringLiteral(";"));
  // ERROR_LOG(m_logger) << entry << " size of split: " << measure.size();
   if (measure.size() < 34 )
     continue;
   Database::PdmSanitationProcedures pros;
   pros.id = measure.at(0).toInt();
   pros.name = measure.at(3);
   pros.longName = measure.at(4);
   pros.type = measure.at(1);
   pros.typeId = measure.at(2).toInt();
   pros.minimumQualification = measure.at(34).toInt()  == 0 ? 3 : measure.at(34).toInt();
   pros.version = m_version;

   pros.dataCode = getCode(pros.type, pros.typeId);
   if(m_db->insert(pros))
   {
     Database::PdmTranslation trans;
     trans.key = measure.at(3);
     trans.disambiguation = QStringLiteral("name");
     trans.context = myContext;
     trans.translation = measure.at(5);
     trans.isoCode = QStringLiteral("en_US");
     m_db->insert(trans);
     trans.id = 0;
     trans.isoCode = QStringLiteral("en_GB");
     m_db->insert(trans);
     trans.id = 0;
     trans.translation = measure.at(3);
     trans.isoCode = QStringLiteral("de_DE");
     m_db->insert(trans);

     //long name:
     trans.id = 0;
     trans.key = measure.at(4);
     trans.disambiguation = QStringLiteral("long_name");

     trans.translation = measure.at(4);
     trans.isoCode = QStringLiteral("de_DE");
     m_db->insert(trans);
     trans.id = 0;
     trans.translation = measure.at(6);
     trans.isoCode = QStringLiteral("en_US");
     m_db->insert(trans);
     trans.id = 0;
     trans.isoCode = QStringLiteral("en_GB");
     m_db->insert(trans);
   }
  }
  return true;
}

bool PvSanImport::addMaterial(const QVector<QString> &material)
{
  if(material.isEmpty())
    return false;
  //check for DatabaseEntry with ID 1 and it's version
  Database::PdmSanitationMaterial matTemp;

  //remove from DB only if version differs
  if (m_db->selectPdmSanitationMaterial(1, matTemp) && matTemp.version == m_version)
    return true;

  //m_db->truncatePdmSanitationMaterial();
  DBTransaction trans(m_db->database());
  NSqlQuery q(m_db->database());

  QString stmt = QStringLiteral("DELETE FROM pdm_sanitation_material");

  q.prepare(stmt);

  DEBUG_LOG(m_logger) << "Statement: " << stmt;

  if (!q.exec())
  {
    WARNING_LOG(m_logger) << "Could not delete sanitation materials";
    return false;
  }

  trans.commit();

  QString myContext = QStringLiteral("SanitationMaterial");
  QVector<Database::PdmTranslation> translations;
  m_db->select(translations);
  QSet<quint64> idsToRemove;
  for (const auto &tr : qAsConst(translations))
  {
    if (tr.context == myContext)
      idsToRemove.insert(tr.id);
  }

  for (quint64 id : idsToRemove )
  {
    m_db->removePdmTranslation(id);
  }

  //insert into db
  for (const QString &entry: material)
  {
   QStringList material = entry.split(QStringLiteral(";"));
   if (material.size() < 3 )
     continue;
   Database::PdmSanitationMaterial mat;
   mat.id = material.at(0).toInt();
   mat.name = material.at(1);
   mat.version = m_version;

   if(m_db->insert(mat))
   {
     Database::PdmTranslation trans;
     trans.key = material.at(1);
     trans.disambiguation = QStringLiteral("name");
     trans.context = myContext;
     trans.translation = material.at(2);
     trans.isoCode = QStringLiteral("en_US");
     m_db->insert(trans);
     trans.id = 0;
     trans.isoCode = QStringLiteral("en_GB");
     m_db->insert(trans);
     trans.id = 0;
     trans.translation = material.at(1);
     trans.isoCode = QStringLiteral("de_DE");
     m_db->insert(trans);
   }
  }
  return true;
}

bool PvSanImport::addInjuryPlaces(const QVector<QString> &kind, const QVector<QString> &place1, const QVector<QString> &place2)
{
  if (kind.isEmpty() || place1.isEmpty() || place2.isEmpty())
    return false;

  //check for DatabaseEntry with ID 1 and it's version
  Database::PdmSanitationInjuryKind kindTemp;

  if (m_db->selectPdmSanitationInjuryKind(1, kindTemp) && kindTemp.version == m_version)
    return true;

  QString myContext = QStringLiteral("SanitationInjuryKind");
  Database::PdmTranslation trans;

  //remove from DB
  m_db->truncatePdmSanitationInjuryKind();

  QVector<Database::PdmTranslation> translations;
  m_db->select(translations);
  QSet<quint64> idsToRemove;
  for (const auto &tr : qAsConst(translations))
  {
    if (tr.context == myContext)
      idsToRemove.insert(tr.id);
  }

  for (quint64 id : idsToRemove )
  {
    m_db->removePdmTranslation(id);
  }

  //insert into db
  trans.context = myContext;
  Database::PdmSanitationInjuryKind injuryKindDb;
  for (const QString &kd : qAsConst(kind))
 {
    QStringList kde = kd.split(QStringLiteral(";"));
    if (kde.size() < 3 )
      continue;
    injuryKindDb.id = kde.at(0).toInt();
    injuryKindDb.name = kde.at(1);
    injuryKindDb.version = m_version;
    if(m_db->insert(injuryKindDb))
    {
      //Add Translation
      trans.id = 0;
      trans.key = injuryKindDb.name;
      trans.disambiguation = QStringLiteral("name");
      trans.translation = kde.at(2);
      trans.isoCode = QStringLiteral("en_US");
      m_db->insert(trans);
      trans.id = 0;
      trans.isoCode = QStringLiteral("en_GB");
      m_db->insert(trans);
      trans.id = 0;
      trans.translation = injuryKindDb.name;
      trans.isoCode = QStringLiteral("de_DE");
      m_db->insert(trans);
    }
 }
  //Place1
  //remove from DB
  myContext = QStringLiteral("SanitationInjuryPlace1");
  m_db->truncatePdmSanitationInjuryPlace1();
  idsToRemove.clear();
  for (const auto &tr : qAsConst(translations))
  {
    if (tr.context == myContext)
      idsToRemove.insert(tr.id);
  }

  for (quint64 id : idsToRemove )
  {
    m_db->removePdmTranslation(id);
  }

  //insert into db
  trans.context = myContext;
  Database::PdmSanitationInjuryPlace1 placeDb;
  for (const QString &place : qAsConst(place1))
 {
    QStringList pl = place.split(QStringLiteral(";"));
    if (pl.size() < 3 )
      continue;
    placeDb.id = pl.at(0).toInt();
    placeDb.name = pl.at(1);
    placeDb.version = m_version;
    if(m_db->insert(placeDb))
    {
      //Add Translation
      trans.id = 0;
      trans.key = placeDb.name;
      trans.disambiguation = QStringLiteral("name");
      trans.translation = pl.at(2);
      trans.isoCode = QStringLiteral("en_US");
      m_db->insert(trans);
      trans.id = 0;
      trans.isoCode = QStringLiteral("en_GB");
      m_db->insert(trans);
      trans.id = 0;
      trans.translation = placeDb.name;
      trans.isoCode = QStringLiteral("de_DE");
      m_db->insert(trans);
    }
 }

  //Place2
  //remove from DB
  myContext = QStringLiteral("SanitationInjuryPlace2");
  m_db->truncatePdmSanitationInjuryPlace2();
  idsToRemove.clear();
  for (const auto &tr : qAsConst(translations))
  {
    if (tr.context == myContext)
      idsToRemove.insert(tr.id);
  }

  for (quint64 id : idsToRemove )
  {
    m_db->removePdmTranslation(id);
  }

  //insert into db
  trans.context = myContext;
  Database::PdmSanitationInjuryPlace2 place2Db;
  for (const QString &place : qAsConst(place2))
 {
    QStringList pl = place.split(QStringLiteral(";"));
    if (pl.size() < 3 )
      continue;
    place2Db.id = pl.at(0).toInt();
    place2Db.name = pl.at(1);
    place2Db.version = m_version;

    if(m_db->insert(place2Db))
    {
      //Add Translation
      trans.id = 0;
      trans.key = place2Db.name;
      trans.disambiguation = QStringLiteral("name");
      trans.translation = pl.at(2);
      trans.isoCode = QStringLiteral("en_US");
      m_db->insert(trans);
      trans.id = 0;
      trans.isoCode = QStringLiteral("en_GB");
      m_db->insert(trans);
      trans.id = 0;
      trans.translation = place2Db.name;
      trans.isoCode = QStringLiteral("de_DE");
      m_db->insert(trans);
    }
 }

  return true;
}

bool PvSanImport::addInjuries(const QVector<QString> &injuries)
{

  if(injuries.isEmpty())
    return false;
  //check for DatabaseEntry with ID 1 and it's version
  QString myContext = QStringLiteral("SanitationInjury");
  Database::PdmTranslation trans;

  //remove from DB
  m_db->truncatePdmSanitationInjury();

  //insert into db
  trans.context = myContext;
  Database::PdmSanitationInjury injuryDb;
  int id = 1;
  for (const QString &injury : qAsConst(injuries))
 {
    QStringList kde = injury.split(QStringLiteral(";"));
    if (kde.size() <  29 )
      continue;
    if (kde.at(1).toInt() < 1)
      continue;
    injuryDb.id = id++;
    injuryDb.kind = kde.at(1).toInt();
    injuryDb.place1 = kde.at(2).toInt();
    injuryDb.place2 = kde.at(3).toInt();
    injuryDb.vbg = kde.at(4).toInt();
    injuryDb.name = kde.at(28) + QStringLiteral(" ") + kde.at(29);
    m_db->insert(injuryDb);
 }


  return true;
}


} // namespace ProjectDataManagement