/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2024, 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-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#ifndef __RENDER_TEST_ENGINE_H_
#define __RENDER_TEST_ENGINE_H_

#include "OdTimeStamp.h"
#include "scenario/ScenarioEngineDataHandler.h"
#include "scenario/EngineScenariosBase.h"
#include "scenario/ScenarioEngineUtils.h"

#ifdef OD_HAVE_WINBASE_H_FILE
#include <WinBase.h>
#endif
#ifdef OD_HAVE_UNISTD_FILE
#include <unistd.h>
#endif

namespace ScenarioEngine
{
  template<class THostAppServices>
  using PRenderTestFunc = void(*)(THostAppServices* app, unsigned testNumber, const OdString& outBmpFile);


  template<class THostAppServices>
  struct RenderTestDef
  {
    PRenderTestFunc<THostAppServices> pf;
    const wchar_t* testName;
    const wchar_t* testFolder;
    unsigned int runsNum;
  };
}

namespace ScenarioEngine
{
  class IOutputFileProvider
  {
  public:
    virtual ~IOutputFileProvider() {}
    virtual OdString  getFileName(int subsetNumber) = 0;
  };


  class OutputFileProviderSingleFile
    : public IOutputFileProvider
  {
  public:
    OutputFileProviderSingleFile(const OdString&  fileToProvide)
      : m_fileToProvide(fileToProvide)
    {
    }

    virtual OdString  getFileName(int subsetNumber)
    {
      return m_fileToProvide;
    }

  private:
    OdString  m_fileToProvide;
  };

  class OutputFileProviderForSubset
    : public IOutputFileProvider
  {
  public:
    OutputFileProviderForSubset(const OdString&  pathPrefix)
      : m_pathPrefix(pathPrefix)
    {
    }

    virtual OdString  getFileName(int subsetNumber)
    {
      OdString fileName;
      OdTimeStamp timeStamp(OdTimeStamp::kInitLocalTime);
      OdUInt32 msecs = timeStamp.msecsPastMidnight();
#if !defined(ODA_WINDOWS)
      uintmax_t procId = (uintmax_t)getpid();
#else
      OdUInt32 procId = GetCurrentProcessId();
#endif
      fileName.format(L"p%u_f%d_t%u.bmp", procId, subsetNumber, msecs);

      return m_pathPrefix + fileName;
    }

  private:
    OdString  m_pathPrefix;
  };
}

namespace ScenarioEngine
{
  namespace
  {
    template<class TAppServices>
    class ServiceSubFolderRestorer
    {
    public:
      ServiceSubFolderRestorer(TAppServices* serviceToChange, const OdString& subDirectory)
        : m_serviceToChang(serviceToChange)
      {
        ODA_ASSERT(m_serviceToChang != NULL);

        if (subDirectory.isEmpty())
        {
          m_serviceToChang = NULL;
        }

        if (m_serviceToChang == NULL)
        {
          return;
        }

        m_oldPath = m_serviceToChang->getBugDirectory();
        ODA_ASSERT(!m_oldPath.isEmpty());

        OdString newPath;
        newPath.format(L"%ls%ls", m_oldPath.c_str(), subDirectory.c_str());

        if (newPath.isEmpty())
        {
          return;
        }

        m_serviceToChang->setBugDirectory(newPath);
      }

      ~ServiceSubFolderRestorer()
      {
        if (m_serviceToChang == NULL || m_oldPath.isEmpty())
        {
          return;
        }

        m_serviceToChang->setBugDirectory(m_oldPath);
      }

    private:
      TAppServices* m_serviceToChang;
      OdString  m_oldPath;
    };
  }

  template<class TAppServices>
  class RenderTestDataHandler
    : public ScenarioEngine::ScenarioDataHandler<RenderTestDef<TAppServices>, TAppServices>
  {
  public:
    RenderTestDataHandler(RenderTestDef<TAppServices>* testDataArray, unsigned int testDataArrayLength)
      : ScenarioEngine::ScenarioDataHandler<RenderTestDef<TAppServices>, TAppServices>(testDataArray, testDataArrayLength)
    {
    }

    virtual int runScenarioImpl(const RenderTestDef<TAppServices>& testData, unsigned int runNumber, TAppServices& hostAppService)
    {
      if (m_ouptuFileProvider.isNull())
      {
        ODA_ASSERT(0);
        return -1;
      }

      if (runNumber > testData.runsNum)
      {
        ODA_ASSERT(0);
        return -1;
      }

      OdString outputFile = m_ouptuFileProvider->getFileName(runNumber);
      ServiceSubFolderRestorer<TAppServices>  folderRestorer(&hostAppService, testData.testFolder);

      odPrintConsoleString(L"TESTNAME:%ls, run = %d\n", testData.testName, runNumber);
      int res = ScenarioEngine::RenderRun<PRenderTestFunc<TAppServices>, TAppServices>(testData.pf, &hostAppService, runNumber, outputFile);
      odPrintConsoleString(L"result = %d\n\n", res);

      return res;
    }

    void setProvider(OdSharedPtr<ScenarioEngine::IOutputFileProvider>&  ouptuFileProvider)
    {
      ODA_ASSERT(m_ouptuFileProvider.isNull());
      m_ouptuFileProvider = ouptuFileProvider;
    }

  private:
    OdSharedPtr<ScenarioEngine::IOutputFileProvider>  m_ouptuFileProvider;
  };
}


namespace ScenarioEngine
{
  template<class THostAppServices, class TOdTestEngineInitializer>
  class RenderScenarioRunByNumber
    : public ScenarioEngine::ScenarioRunByNumberBase<RenderTestDef<THostAppServices>, THostAppServices, TOdTestEngineInitializer, RenderTestDataHandler<THostAppServices> >
  {
  public:
    RenderScenarioRunByNumber(RenderTestDataHandler<THostAppServices>& testDataHandler)
      : ScenarioEngine::ScenarioRunByNumberBase<RenderTestDef<THostAppServices>, THostAppServices, TOdTestEngineInitializer, RenderTestDataHandler<THostAppServices> >(testDataHandler)
    {
    }

  protected:
    virtual void  showDescription(const wchar_t* startAppName)
    {
      ScenarioEngine::printConsoleString(L"%s <NUMBER> <PATH> <OUTPUT_FILE>\n", startAppName);
      ScenarioEngine::printConsoleString(L"NUMBER - index of test(subtest) in test collection. Single test run..\n");
      ScenarioEngine::printConsoleString(L"PATH - path to folder with support files.\n");
      ScenarioEngine::printConsoleString(L"OUTPUT_FILE - path to ouptut file.\n");
      ScenarioEngine::printConsoleString(L"\n");
    }

    virtual bool  parseParams(int argc, test_arg_char* argv[], OdString& pathToExecutableFile, OdString& pathToTestFolder, int& subTestNumber)
    {
      ScenarioEngine::CmdParseRule  parserRule(ScenarioEngine::cmdParamStrictCompliance);

      OdString      pathToOutputFile;

      parserRule << pathToExecutableFile;
      parserRule << subTestNumber;
      parserRule << pathToTestFolder;
      parserRule << pathToOutputFile;

      if (!parserRule.parse(argc, argv))
      {
        return false;
      }

      OdSharedPtr<IOutputFileProvider>  fileProvider(new OutputFileProviderSingleFile(pathToOutputFile));
      this->m_dataHandler.setProvider(fileProvider);

      return true;
    }
  };

}

namespace ScenarioEngine
{
  template<class THostAppServices, class TOdTestEngineInitializer>
  class RenderScenarioRunByName
    : public ScenarioEngine::ScenarioRunByNameBase<RenderTestDef<THostAppServices>, THostAppServices, TOdTestEngineInitializer, RenderTestDataHandler<THostAppServices> >
  {
  public:
    RenderScenarioRunByName(RenderTestDataHandler<THostAppServices>& testDataHandler)
      : ScenarioEngine::ScenarioRunByNameBase<RenderTestDef<THostAppServices>, THostAppServices, TOdTestEngineInitializer, RenderTestDataHandler<THostAppServices> >(testDataHandler)
    {
    }

  protected:
    virtual void  showDescription(const wchar_t* startAppName)
    {
      ScenarioEngine::printConsoleString(L"%s <TESTNAME> <PATH> <OUTPUT_FILE_PREFIX>\n", startAppName);
      ScenarioEngine::printConsoleString(L"TESTNAME - name of test in test collection. Single test run.\n");
      ScenarioEngine::printConsoleString(L"PATH - path to folder with support files.\n");
      ScenarioEngine::printConsoleString(L"OUTPUT_FILE_PREFIX - file prefix for each iteration from subset test collection.\n");
      ScenarioEngine::printConsoleString(L"\n");
    }

    virtual bool  parseParams(int argc, test_arg_char* argv[], OdString& pathToExecutableFile, OdString& pathToTestFolder, OdString& testName)
    {
      ScenarioEngine::CmdParseRule  parserRule(ScenarioEngine::cmdParamStrictCompliance);

      OdString      pathToOutputFile;

      parserRule << pathToExecutableFile;
      parserRule << testName;
      parserRule << pathToTestFolder;
      parserRule << pathToOutputFile;

      if (!parserRule.parse(argc, argv))
      {
        return false;
      }

      OdSharedPtr<IOutputFileProvider>  fileProvider(new OutputFileProviderForSubset(pathToOutputFile));
      this->m_dataHandler.setProvider(fileProvider);

      return true;
    }
  };

}


namespace ScenarioEngine
{
  template<class THostAppServices, class TOdTestEngineInitializer>
  class RenderScenarioRunAll
    : public ScenarioEngine::ScenarioRunAllBase<RenderTestDef<THostAppServices>, THostAppServices, TOdTestEngineInitializer, RenderTestDataHandler<THostAppServices> >
  {
  public:
    RenderScenarioRunAll(RenderTestDataHandler<THostAppServices>& testDataHandler)
      : ScenarioEngine::ScenarioRunAllBase<RenderTestDef<THostAppServices>, THostAppServices, TOdTestEngineInitializer, RenderTestDataHandler<THostAppServices> >(testDataHandler)
    {
    }

  private:
    virtual bool  parseParams(int argc, test_arg_char* argv[], OdString& pathToExecutableFile, OdString& pathToTestFolder)
    {
      ScenarioEngine::CmdParseRule  parserRule(ScenarioEngine::cmdParamStrictCompliance);
      OdString      testAllKeyword;
      OdString      pathToOutputFile;

      parserRule << pathToExecutableFile;
      parserRule << testAllKeyword;
      parserRule << pathToTestFolder;
      parserRule << pathToOutputFile;

      if (!parserRule.parse(argc, argv) || testAllKeyword.iCompare("ALL"))
      {
        return false;
      }

      OdSharedPtr<IOutputFileProvider>  fileProvider(new OutputFileProviderForSubset(pathToOutputFile));
      this->m_dataHandler.setProvider(fileProvider);

      return true;
    }

    virtual void  showDescription(const wchar_t* startAppName)
    {
      ScenarioEngine::printConsoleString(L"%s ALL <PATH> <OUTPUT_FILE_PREFIX>\n", startAppName);
      ScenarioEngine::printConsoleString(L"ALL is a keyword. Run all tests from test collection one by one (not safe way).\n");
      ScenarioEngine::printConsoleString(L"PATH - path to folder with support files.\n");
      ScenarioEngine::printConsoleString(L"OUTPUT_FILE_PREFIX - file prefix for each iteration from subset test collection.\n");
      ScenarioEngine::printConsoleString(L"\n");
    }

  };
}


#endif // __RENDER_TEST_ENGINE_H_