/**
 * Handler for report charge administration
 * $Id$
 * $HeadURL$
 * $Author$
 * Created by Hanna E. Rathje, SLSE, 2016-12-20
 */

#include "handler_report_data.h"

#include <ngldb/dbtransaction.h>
#include <ngldb/nsqlquery.h>

#include <QVariant>

using namespace ReportManagement;

// ------------------------------------------------------------------------------------------------------------------
bool HandlerReportData::generateChargeAdminResult(const CreateModifyReportRequest &request, int reportId)
{
  INFO_LOG(m_logger) << "Start generateChargeAdminResult ";

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

  q.prepare(QLatin1String("INSERT INTO rep_charge_administration (report_id, effect_source_id, charge_type_id ) VALUES (:reportId, :effectSourceId, :chargeTypeId )"));
  q.bindValue(QLatin1String(":reportId"), reportId);

  for (auto it1 = request.effectSources().begin(); it1 != request.effectSources().end(); ++it1)
  {
    ProjectDataManagement::EffectSource effectSourceId = *it1;
    q.bindValue(QLatin1String(":effectSourceId"), effectSourceId.underlying());

    for (auto it2 = request.chargeTypeIds().begin(); it2 != request.chargeTypeIds().end(); ++it2)
    {
      int chargeTypeId = *it2;
      if (chargeTypeId == 0)
        continue; // skip 0

      q.bindValue(QLatin1String(":chargeTypeId"), chargeTypeId);
      DEBUG_LOG(m_logger) << " Inserting chargeTypeId " << chargeTypeId;
      if (!q.exec())
      {
        ERROR_LOG(m_logger) << "Error inserting report id, effectSourceId, chargeTypeId = " << reportId << " , " << effectSourceId << " , " << chargeTypeId;
        return false;
      }

      if (!calculateStock(chargeTypeId, effectSourceId, request.startTime(), request.endTime(), request.partyId(), reportId))
        return false;
    }
  }

  trans.commit();

  INFO_LOG(m_logger) << " END generateChargeAdminResult";
  return true;
}

// ------------------------------------------------------------------------------------------------------------------
bool HandlerReportData::calculateStock(int chargeTypeId, const ProjectDataManagement::EffectSource &es, qint64 startTime, qint64 endTime, int partyId, int reportId)
{
  ChargeTypeData chargeData;
  chargeData.chargeTypeId = chargeTypeId;
  chargeData.effectSourceId = es;

  NSqlQuery qSelect(m_db->database());
  NSqlQuery qInit(m_db->database());
  NSqlQuery qUpdate(m_db->database());
  QString stmt = QLatin1String("SELECT amount, planned, used, sample_time, charge_type_id "
                               " FROM rec_charge_administration "
                               " WHERE effect_source_id = ")
                 + QString::number(es.underlying()) + QLatin1String(" AND sample_time > 0 AND sample_time < ") + QString::number(startTime)
                 + QLatin1String(" AND party_id = ") + QString::number(partyId) + QLatin1String(" AND charge_type_id = ") + QString::number(chargeTypeId)
                 + QLatin1String(" ORDER BY sample_time DESC LIMIT 1");

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

  if (!qInit.exec(stmt))
  {
    ERROR_LOG(m_logger) << "Error while selecting start-data for chargeTypeId " << chargeTypeId << ", stmt='" << stmt << "'";
    return false;
  }
  if (!qInit.next()) // not found a valid record
  {
    INFO_LOG(m_logger) << "No start entry for chargeTypeId " << chargeTypeId << ", assuming 0";
    // return true;
    chargeData.chargeQuantity = 0;
    chargeData.chargeQuantityStart = 0;
    chargeData.usedCharge = 0;
    chargeData.usedChargeStart = 0;
    chargeData.chargeAddition = 0;
    chargeData.chargePlanned = 0;
    //    chargeData.chargeAvailable     = 0;
  }
  else
  {
    qInit.first();
    chargeData.chargeQuantity = qInit.value(0).toInt(); // + qInit.value(1).toInt();
    chargeData.chargeQuantityStart = chargeData.chargeQuantity;
    chargeData.usedCharge = qInit.value(2).toInt();
    chargeData.chargePlanned = qInit.value(1).toInt();
    chargeData.usedChargeStart = chargeData.usedCharge;
    chargeData.chargeAddition = 0;
    //    chargeData.chargeAvailable     = chargeData.chargeQuantityStart - chargeData.usedChargeStart;
  }

  DEBUG_LOG(m_logger) << "START chargeTypeId  =  " << QString::number(chargeTypeId) << " , "
                      << " effectSourceId = " << es << "chargeQuantityStart =  " << chargeData.chargeQuantityStart << " , "
                      << "usedChargeStart     =  " << chargeData.usedChargeStart;

  stmt = QLatin1String("SELECT charge_type_id, amount, planned, used, amount_changed_by_operator "
                       " FROM rec_charge_administration "
                       " WHERE sample_time >= ")
         + QString::number(startTime) + QLatin1String(" AND sample_time <= ") + QString::number(endTime) + QLatin1String(" AND party_id = ") + QString::number(partyId)
         + QLatin1String(" AND charge_type_id = ") + QString::number(chargeTypeId) + QLatin1String(" AND effect_source_id = ") + QString::number(es.underlying())
         + QLatin1String(" ORDER BY sample_time ");

  if (!qSelect.exec(stmt))
  {
    ERROR_LOG(m_logger) << "Error while selecting charge-data for chargeTypeId " << chargeTypeId;
    return false;
  }

  DEBUG_LOG(m_logger) << "Select statement: " << stmt;

  while (qSelect.next())
  {
    int quantity = qSelect.value(1).toInt(); // + qSelect.value(2).toInt();

    chargeData.chargeQuantity = quantity;
    chargeData.usedCharge = qSelect.value(3).toInt();
    chargeData.chargePlanned = qSelect.value(2).toInt();
    chargeData.chargeAddition = chargeData.chargeQuantity + chargeData.usedCharge - chargeData.chargeQuantityStart;

    DEBUG_LOG(m_logger) << "CALCULATING for chargeTypeId =  " << QString::number(chargeData.chargeTypeId) << " quantity =  " << quantity << " , "
                        << " munQuantity =  " << chargeData.chargeQuantity << " , "
                        << " munAddition =  " << chargeData.chargeAddition << " , "
                        << " usedMunition =  " << chargeData.usedCharge << " , "
                        << " planned = " << chargeData.chargePlanned;
  }

  DEBUG_LOG(m_logger) << "UPDATING stock for chargeTypeId: " << chargeData.chargeTypeId << " values: " << chargeData.chargeQuantityStart << " , "
                      << chargeData.chargeAddition << " , " << chargeData.chargeQuantity << " , " << chargeData.usedCharge - chargeData.usedChargeStart << " , "
                      << chargeData.chargePlanned << " , " << chargeData.chargeQuantity - chargeData.chargePlanned;

  stmt = QLatin1String("UPDATE rep_charge_administration SET "
                       " charge_start = ")
         + QString::number(chargeData.chargeQuantityStart) + QLatin1String(", ") + QLatin1String(" charge_resupplied = ") + QString::number(chargeData.chargeAddition)
         + QLatin1String(", ") + QLatin1String(" charge_end = ") + QString::number(chargeData.chargeQuantity) + QLatin1String(", ") + QLatin1String(" charge_fired = ")
         + QString::number(chargeData.usedCharge - chargeData.usedChargeStart) + QLatin1String(", ") + QLatin1String(" charge_planned = ")
         + QString::number(chargeData.chargePlanned) + QLatin1String(", ") + QLatin1String(" charge_available = ")
         + QString::number(chargeData.chargeQuantity - chargeData.chargePlanned) + QLatin1String(" WHERE report_id = ") + QString::number(reportId)
         + QLatin1String(" AND charge_type_id = ") + QString::number(chargeData.chargeTypeId) + QLatin1String(" AND effect_source_id = ")
         + QString::number(es.underlying());

  DEBUG_LOG(m_logger) << "Update statement: " << stmt;

  if (!qUpdate.exec(stmt))
  {
    ERROR_LOG(m_logger) << "Error while updating stock for chargeTypeId " << chargeTypeId;
    return false;
  }

  return true;
}