#include "OdaCommon.h"
#include "ExPrintConsole.h"
#include <ctime>

#include "daiModule.h"
#include "daiVersion.h"
#include "ExValidationCommon.h"
#include "ExHtmlValidationNotifier.h"

using namespace OdDAI;

ODRX_CONS_DEFINE_MEMBERS(HtmlValidationNotifier, ValidationNotifier, RXIMPL_CONSTR);

void HtmlValidationNotifier::onValidationResult(OdDAIObjectId instanceId, ValidationTaskPtr validationTask, OdSharedPtr<ValidationTask::InvalidValidationParamsBase> invalidParams, Logical result)
{
  if (instanceId != m_actualInstanceId)
  {
    addInstanceToFile();
    m_actualInstanceId = instanceId;
    m_invalidAttributes.clear();
  }

  if (ValidationTask::InvalidValidationParams* invalidValidationParams = dynamic_cast<ValidationTask::InvalidValidationParams*>(invalidParams.get()))
  {
    if (invalidValidationParams->invalidAttributes.size() > 0 && invalidValidationParams->invalidWhereRules.size() > 0)
    {
      for (int i = 0; i < static_cast<int>(invalidValidationParams->invalidAttributes.size()); ++i)
      {
        m_invalidAttributes.insert(std::make_pair(invalidValidationParams->invalidAttributes.at(i)->originalName() + 
                                                  " (WR: " + 
                                                  invalidValidationParams->invalidWhereRules.at(i)->originalLabel() + 
                                                  ")", std::make_pair(validationTask->description(), result)));
      }
      m_statistics.addResult(result, invalidValidationParams->invalidAttributes.size());
    }
    else if (invalidValidationParams->invalidAttributes.size() > 0)
    {
      for (auto it : invalidValidationParams->invalidAttributes)
      {
        m_invalidAttributes.insert(std::make_pair(it->originalName(), std::make_pair(validationTask->description(), result)));
      }
      m_statistics.addResult(result, invalidValidationParams->invalidAttributes.size());
    }
    else if (invalidValidationParams->invalidWhereRules.size() > 0)
    {
      for (auto it : invalidValidationParams->invalidWhereRules)
      {
        m_invalidAttributes.insert(std::make_pair("WR:" + it->originalLabel(), std::make_pair(validationTask->description(), result)));
      }
      m_statistics.addResult(result, invalidValidationParams->invalidWhereRules.size());
    }
    else
    {
      m_invalidAttributes.insert(std::make_pair(nullptr, std::make_pair(validationTask->description(), result)));
      m_statistics.addResult(result, 1);
    }
  }
  else if (OdDAI::ValidationTask::InvalidRxArrayValidationParams* invalidValidationParams = dynamic_cast<OdDAI::ValidationTask::InvalidRxArrayValidationParams*>(invalidParams.get()))
  {
    for (const auto& params : invalidValidationParams->invalidParams)
    {
      m_invalidAttributes.insert(std::make_pair(translateObjectsArrayToText(params.invalidObjects, "<br>"),
        std::make_pair((params.textMessage.isEmpty() ? validationTask->description() : validationTask->description() + "<br>" + params.textMessage),
          params.validationResult)));
    }
    m_statistics.addResult(result, invalidValidationParams->invalidParams.size());
  }
  else if (OdDAI::ValidationTask::InvalidRxObjectsValidationParams* invalidValidationParams = dynamic_cast<OdDAI::ValidationTask::InvalidRxObjectsValidationParams*>(invalidParams.get()))
  {
    m_invalidAttributes.insert(std::make_pair(translateObjectsArrayToText(invalidValidationParams->invalidObjects, "<br>"),
      std::make_pair((invalidValidationParams->textMessage.isEmpty() ? validationTask->description() : validationTask->description() + "<br>" + invalidValidationParams->textMessage),
        invalidValidationParams->validationResult)));
    m_statistics.addResult(result, invalidValidationParams->invalidObjects.size());
  }
  else if (OdDAI::ValidationTask::InvalidObjectIdsValidationParams* invalidValidationParams = dynamic_cast<OdDAI::ValidationTask::InvalidObjectIdsValidationParams*>(invalidParams.get()))
  {
    m_invalidAttributes.insert(std::make_pair(translateObjectsArrayToText(invalidValidationParams->invalidObjects, "<br>"),
      std::make_pair((validationTask->description()), result)));
    m_statistics.addResult(result, invalidValidationParams->invalidObjects.size());
  }
  else if (const OdDAI::ValidationTask::InvalidInstanceValidationParams* idsInvalidParams = dynamic_cast<const OdDAI::ValidationTask::InvalidInstanceValidationParams*>(invalidParams.get()))
  {
    if (idsInvalidParams->invalidParams.size() > 0)
    {
      for (auto it : idsInvalidParams->invalidParams)
      {
        m_invalidAttributes.insert(std::make_pair((it.invalidInstance ? (getInstanceName(it.invalidInstance->id()) + ": ") : OdAnsiString())
          + (it.invalidAttribute ? it.invalidAttribute->originalName().c_str() : ""), std::make_pair(validationTask->description()
            + ":\n" + it.instruction.c_str(), result)));
      }
      m_statistics.addResult(result, idsInvalidParams->invalidParams.size());
    }
    else
    {
      m_invalidAttributes.insert(std::make_pair(nullptr, std::make_pair(validationTask->description(), result)));
      m_statistics.addResult(result, 1);
    }
  }
  else
  {
    m_invalidAttributes.insert(std::make_pair(nullptr, std::make_pair(validationTask->description(), result)));
    m_statistics.addResult(result, 1);
  }
}

void HtmlValidationNotifier::onValidationResult(ValidationTaskPtr validationTask, const OdDAIObjectIds& invalidObjects, OdDAI::Logical result)
{
  if (invalidObjects.size() > 0)
  {
    m_htmlOutFile << "<tr><td>";
    for (auto it : invalidObjects)
    {
      m_htmlOutFile << "#" << (OdUInt64)it.getHandle() << " " << it.getNested()->typeName().c_str();
      if (&it != &invalidObjects.last())
        m_htmlOutFile << "<br>";
    }
    m_htmlOutFile << "</td><td></td><td>" << validationTask->description().c_str() << "</td><td>" << result2string(result).c_str() << "</td></tr>\n";
  }
  else
  {
    m_htmlOutFile << "<tr><td></td><td></td><td>" << validationTask->description().c_str() << "</td><td>" << result2string(result).c_str() << "</td></tr>\n";
  }
}

void HtmlValidationNotifier::addInstanceToFile()
{
  int ununicAttrCountdown = 0;
  for (auto it = m_invalidAttributes.cbegin(); it != m_invalidAttributes.cend(); ++it)
  {
    m_htmlOutFile << "\t<div class=\"report-";
    if (it->second.second == OdDAI::Logical::True)
      m_htmlOutFile << "ok\">\n";
    else if (it->second.second == OdDAI::Logical::False)
      m_htmlOutFile << "error\">\n";
    else if (it->second.second == OdDAI::Logical::Unset)
      m_htmlOutFile << "unset\">\n";
    else if (it->second.second == OdDAI::Logical::Unknown)
      m_htmlOutFile << "unknown\">\n";

    if (it == m_invalidAttributes.cbegin())
    {
      if (m_actualInstanceId)
        m_htmlOutFile << "\t\t<div>#" << (OdUInt64)m_actualInstanceId.getHandle() << " " << m_actualInstanceId.getNested()->getInstanceType()->originalName().c_str() << "</div>\n";
      else
        m_htmlOutFile << "\t\t<div>" << (it->first ? it->first : "") << "</div>\n";
    }
    else
    {
      m_htmlOutFile << "\t\t<div></div>\n";
    }
    if (!ununicAttrCountdown)
    {
      if (it == m_invalidAttributes.cbegin() && !m_actualInstanceId)
        m_htmlOutFile << "\t\t<div>" << "Model validation" << "</div>\n";
      else
      {
        ununicAttrCountdown = static_cast<int>(m_invalidAttributes.count(it->first));
        m_htmlOutFile << "\t\t<div>" << (it->first ? it->first : "") << "</div>\n";
      }
    }
    else
      m_htmlOutFile << "\t\t<div></div>\n";

    m_htmlOutFile << "\t\t<div>" << it->second.first.c_str() << "</div>\n";
    m_htmlOutFile << "\t\t<div></div>\n\t</div>\n";

    --ununicAttrCountdown;
  }
}

void HtmlValidationNotifier::changeInfo(const OdAnsiString& info)
{
  std::string line;
  getline(m_htmlTemplate, line);
  auto place = line.find("[insert]");
  if (place != std::string::npos)
  {
    line.erase(place, 8);
    line.insert(place, info);
    m_htmlOutFile << line << "\n";
  }
}

void HtmlValidationNotifier::onStartValidation()
{
  m_htmlTemplate.open("../../../../../Ifc/Data/validationTemplate.html");

  if (!m_htmlTemplate.is_open())
    m_htmlTemplate.open("Plugins/validationTemplate.html");

  if (!m_htmlTemplate.is_open())
    throw("Could not open template");

  m_htmlOutFile.open(m_fileName.c_str());

  if (!m_htmlOutFile.is_open())
    throw("Wrong html file name");

  std::string line;
  while (getline(m_htmlTemplate, line))
  {
    if (line.find("<!--error-class-deff-->") != std::string::npos)
      m_htmlOutFile << "\t\tcontent: \"Error\";\n";
    else if (line.find("<!--ok-class-deff-->") != std::string::npos)
      m_htmlOutFile << "\t\tcontent: \"Ok\";\n";
    else if (line.find("<!--header_insert-->") != std::string::npos)
    {
      m_htmlOutFile << "<strong>ODA SDAI version: </strong>" << TSTEPTK_MAJOR_VERSION << "." << TSTEPTK_MINOR_VERSION << "\n<br>\n";
      changeInfo(m_extraInfo->fileName.c_str());
      changeInfo(m_extraInfo->schemaName.c_str());
      time_t seconds = time(NULL);
      changeInfo(std::ctime(&seconds));
    }
    else if (line.find("<!--place_for_table_insertion-->") != std::string::npos)
    {
      break;
    }
    else
      m_htmlOutFile << line << "\n";
  }
}

void HtmlValidationNotifier::onEndValidation()
{
  addInstanceToFile();
  std::string line; 
  while (getline(m_htmlTemplate, line))
  {
    if (line.find("<!--statistics-->") != std::string::npos)
    {
      m_htmlOutFile << "<br><p class=\"description\">\n"
        << "\t<strong>Errors: </strong>" << m_statistics.errors << "<br>\n"
        << "\t<strong>Unknown: </strong>" << m_statistics.unknown << "<br>\n"
        << "\t<strong>Unset: </strong>" << m_statistics.unset << "<br>\n";
      if (m_extraInfo && m_extraInfo->validationTime != OdDAI::Consts::OdULongUnset)
        m_htmlOutFile << "\t<strong>Validation time: </strong>" << m_extraInfo->validationTime << " msec<br>\n";
      m_htmlOutFile << "\t</p>\n";
    }
    else
      m_htmlOutFile << line << "\n";
  }
  m_htmlTemplate.close();
  m_htmlOutFile.close();
}

void HtmlValidationNotifier::setFileName(const OdAnsiString& fileName)
{
  m_fileName = fileName;
}