/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////
#include "OdaCommon.h"
#include "ExPrintConsole.h"
#include <ctime>

#include "daiModule.h"
#include "daiVersion.h"

#include "ExValidationCommon.h"
#include "ExTextValidationNotifier.h"

using namespace OdDAI;

ODRX_CONS_DEFINE_MEMBERS(TextValidationNotifier, ValidationNotifier, RXIMPL_CONSTR);



void TextValidationNotifier::onValidationResult(ValidationTaskPtr validationTask, const OdDAIObjectIds& invalidObjects, OdDAI::Logical result)
{
  if (invalidObjects.size() > 0)
  {
    for (auto it : invalidObjects)
    {
      m_textOutFile << "#" << (OdUInt64)it.getHandle() << " " << it.getNested()->typeName().c_str() << " ";
    }
    m_textOutFile << "\t" << validationTask->description().c_str() << " \t" << result2string(result).c_str() << "\n";
    m_statistics.addResult(result, invalidObjects.size());
  }
  else
  {
    m_textOutFile << validationTask->description().c_str() << " \t" << result2string(result).c_str() << "\n";
  }
}

void TextValidationNotifier::onStartValidation()
{
  m_textOutFile.open(m_fileName.c_str());
  if (!m_textOutFile.is_open())
    throw("Wrong text file name");
  
  m_textOutFile << "Automatically generated validation log file\n";
  
  if (m_putVersion)
  {
    m_textOutFile << "ODA SDAI version: " << TSTEPTK_MAJOR_VERSION << "." << TSTEPTK_MINOR_VERSION << "\n";
  }

  if (m_extraInfo)
  {
    m_textOutFile << "File name: " << m_extraInfo->fileName.c_str() << "\n"
      << "File schema: " << m_extraInfo->schemaName.c_str() << "\n";
  }

  if (m_putDate)
  {
    time_t seconds = time(NULL);
    m_textOutFile << "Date: " << std::ctime(&seconds) << "\n\n\n";
  }
}

void TextValidationNotifier::onEndValidation()
{
  m_textOutFile << "\n" << "Errors: " << m_statistics.errors << "\n";
  m_textOutFile << "Unknown: " << m_statistics.unknown << "\n";
  m_textOutFile << "Unset: " << m_statistics.unset << "\n";

  if (m_extraInfo && m_extraInfo->validationTime != OdDAI::Consts::OdULongUnset)
    m_textOutFile << "Validation time: " << m_extraInfo->validationTime << " msec\n";

  m_textOutFile.close();
}

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

void TextValidationNotifier::setDateFieldMode(bool putDate)
{
  m_putDate = putDate;
}

void TextValidationNotifier::setVersionFieldMode(bool putVersion)
{
  m_putVersion = putVersion;
}

void TextValidationNotifier::onValidationResult(OdDAIObjectId instanceId, ValidationTaskPtr validationTask, OdSharedPtr<ValidationTask::InvalidValidationParamsBase> invalidParams, Logical result)
{
  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_textOutFile << "#" 
          << (OdUInt64)instanceId.getHandle() << " " 
          << instanceId.getNested()->typeName().c_str() << " \t" 
          << invalidValidationParams->invalidAttributes.at(i)->originalName().c_str() 
          << " (WR:" << invalidValidationParams->invalidWhereRules.at(i)->originalLabel().c_str()  << ")\t\t" 
          << validationTask->description().c_str() 
          << " \t" << result2string(result).c_str() << "\n";
      }
      m_statistics.addResult(result, invalidValidationParams->invalidWhereRules.size());
    }
    else if (invalidValidationParams->invalidAttributes.size() > 0)
    {
      for (auto it : invalidValidationParams->invalidAttributes)
      {
        m_textOutFile << "#" << (OdUInt64)instanceId.getHandle() << " " << instanceId.getNested()->typeName().c_str() << " \t" << it->originalName().c_str() << " \t\t" << validationTask->description().c_str() << " \t" << result2string(result).c_str() << "\n";
      }
      m_statistics.addResult(result, invalidValidationParams->invalidAttributes.size());
    }
    else if (invalidValidationParams->invalidWhereRules.size() > 0)
    {
      for (auto it : invalidValidationParams->invalidWhereRules)
      {
        m_textOutFile << "#" << (OdUInt64)instanceId.getHandle() << " " << instanceId.getNested()->typeName().c_str() << " \tWR:" << it->originalLabel().c_str() << " \t\t" << validationTask->description().c_str() << " \t" << result2string(result).c_str() << "\n";
      }
      m_statistics.addResult(result, invalidValidationParams->invalidWhereRules.size());
    }
    else
    {
      m_textOutFile << "#" << (OdUInt64)instanceId.getHandle() << " " << instanceId.getNested()->typeName().c_str() << " \t\t" << validationTask->description().c_str() << " \t" << result2string(result).c_str() << "\n";
      m_statistics.addResult(result, 1);
    }
  }
  else if (OdDAI::ValidationTask::InvalidRxArrayValidationParams* invalidValidationParams = dynamic_cast<OdDAI::ValidationTask::InvalidRxArrayValidationParams*>(invalidParams.get()))
  {
    for (const auto& params : invalidValidationParams->invalidParams)
    {
      for (auto obj : params.invalidObjects)
      {
        m_textOutFile << translateObjectToText(obj) << "  ";
      }
      m_textOutFile << " \t\t" << validationTask->description().c_str() << " \t" << params.textMessage.c_str() << " \t" << result2string(params.validationResult).c_str() << "\n";
    }
    m_statistics.addResult(result, invalidValidationParams->invalidParams.size());
  }
  else if (OdDAI::ValidationTask::InvalidRxObjectsValidationParams* invalidValidationParams = dynamic_cast<OdDAI::ValidationTask::InvalidRxObjectsValidationParams*>(invalidParams.get()))
  {
    for (auto obj : invalidValidationParams->invalidObjects)
    {
      m_textOutFile << translateObjectToText(obj) << "  ";
    }
    m_statistics.addResult(result, invalidValidationParams->invalidObjects.size());
    m_textOutFile << " \t\t" << validationTask->description().c_str() << " \t" << invalidValidationParams->textMessage.c_str() << " \t" << result2string(invalidValidationParams->validationResult).c_str() << "\n";
    m_statistics.addResult(result, 1);
  }
  else
    if (instanceId.isValid())
    {
      m_textOutFile << "#" << (OdUInt64)instanceId.getHandle() << " " << instanceId.getNested()->typeName().c_str() << " \t\t" << validationTask->description().c_str() << " \t" << result2string(result).c_str() << "\n";
      m_statistics.addResult(result, 1);
    }
    else
    {
      m_textOutFile << "instanceId is invalid\n";
      m_statistics.addResult(result, 1);
    }
}