#ifndef REDUCEDMODELOPTIMIZER_STRUCTS_HPP
#define REDUCEDMODELOPTIMIZER_STRUCTS_HPP
#include "csvfile.hpp"
#include "drmsimulationmodel.hpp"
#include "linearsimulationmodel.hpp"
#include "simulation_structs.hpp"
#include "unordered_map"
#include <string>

namespace ReducedPatternOptimization {

enum BaseSimulationScenario {
    Axial,
    Shear,
    Bending,
    Dome,
    Saddle,
    NumberOfBaseSimulationScenarios
};
inline static std::vector<std::string> baseSimulationScenarioNames{"Axial",
                                                                   "Shear",
                                                                   "Bending",
                                                                   "Dome",
                                                                   "Saddle"};

struct Colors
{
    inline static std::array<double, 3> fullInitial{0.416666, 0.109804, 0.890196};
    inline static std::array<double, 3> fullDeformed{0.583333, 0.890196, 0.109804};
    inline static std::array<double, 3> reducedInitial{0.890196, 0.109804, 0.193138};
    inline static std::array<double, 3> reducedDeformed{0.109804, 0.890196, 0.806863};
};

      struct xRange{
      std::string label;
    double min;
    double max;
    std::string toString() const {
      return label + "=[" + std::to_string(min) + "," + std::to_string(max) +
             "]";
    }

    void fromString(const std::string &s)
    {
        const std::size_t equalPos = s.find("=");
        label = s.substr(0, equalPos);
        const std::size_t commaPos = s.find(",");
        const size_t minBeginPos = equalPos + 2;
        min = std::stod(s.substr(minBeginPos, commaPos - minBeginPos));
        const size_t maxBeginPos = commaPos + 1;
        const std::size_t closingBracketPos = s.find("]");
        max = std::stod(s.substr(maxBeginPos, closingBracketPos - maxBeginPos));
    }

    bool operator==(const xRange &xrange) const
    {
        return label == xrange.label && min == xrange.min && max == xrange.max;
    }
      };
  struct Settings
  {
      enum NormalizationStrategy { NonNormalized, Epsilon };
      std::vector<xRange> xRanges;
      inline static vector<std::string> normalizationStrategyStrings{"NonNormalized", "Epsilon"};
      int numberOfFunctionCalls{100000};
      double solverAccuracy{1e-2};
      NormalizationStrategy normalizationStrategy{Epsilon};
      double normalizationParameter{0.003};
      struct ObjectiveWeights
      {
          double translational{1};
          double rotational{1};
      } objectiveWeights;

      struct JsonKeys
      {
          inline static std::string filename{"OptimizationSettings.json"};
          inline static std::string OptimizationVariables{"OptimizationVariables"};
          inline static std::string NumberOfFunctionCalls{"NumberOfFunctionCalls"};
          inline static std::string SolverAccuracy{"SolverAccuracy"};
          inline static std::string TranslationalObjectiveWeight{"TransObjWeight"};
      };

      void save(const std::filesystem::path &saveToPath)
      {
          assert(std::filesystem::is_directory(saveToPath));

          nlohmann::json json;
          //write x ranges
          for (size_t xRangeIndex = 0; xRangeIndex < xRanges.size(); xRangeIndex++) {
              const auto &xRange = xRanges[xRangeIndex];
              json[JsonKeys::OptimizationVariables + "_" + std::to_string(xRangeIndex)]
                  = xRange.toString();
          }

          json[JsonKeys::NumberOfFunctionCalls] = numberOfFunctionCalls;
          json[JsonKeys::SolverAccuracy] = solverAccuracy;
          json[JsonKeys::TranslationalObjectiveWeight] = objectiveWeights.translational;

          std::filesystem::path jsonFilePath(
              std::filesystem::path(saveToPath).append(JsonKeys::filename));
          std::ofstream jsonFile(jsonFilePath.string());
          jsonFile << json;
      }

      bool load(const std::filesystem::path &loadFromPath)
      {
          assert(std::filesystem::is_directory(loadFromPath));
          //Load optimal X
          nlohmann::json json;
          std::filesystem::path jsonFilepath(
              std::filesystem::path(loadFromPath).append(JsonKeys::filename));
          if (!std::filesystem::exists(jsonFilepath)) {
              return false;
          }
          std::ifstream ifs(jsonFilepath);
          ifs >> json;

          //read x ranges
          size_t xRangeIndex = 0;
          while (true) {
              const std::string jsonXRangeKey = JsonKeys::OptimizationVariables + "_"
                                                + std::to_string(xRangeIndex);
              if (!json.contains(jsonXRangeKey)) {
                  break;
              }
              xRange x;
              x.fromString(json.at(jsonXRangeKey));
              xRanges.push_back(x);
              xRangeIndex++;
          }

          numberOfFunctionCalls = json.at(JsonKeys::NumberOfFunctionCalls);
          solverAccuracy = json.at(JsonKeys::SolverAccuracy);
          objectiveWeights.translational = json.at(JsonKeys::TranslationalObjectiveWeight);
          objectiveWeights.rotational = 2 - objectiveWeights.translational;
          return true;
      }

      std::string toString() const
      {
          std::string settingsString;
          if (!xRanges.empty()) {
              std::string xRangesString;
              for (const xRange &range : xRanges) {
                  xRangesString += range.toString() + " ";
              }
              settingsString += xRangesString;
          }
          settingsString += "FuncCalls=" + std::to_string(numberOfFunctionCalls)
                            + " Accuracy=" + std::to_string(solverAccuracy)
                            + " TransWeight=" + std::to_string(objectiveWeights.translational)
                            + " RotWeight=" + std::to_string(objectiveWeights.rotational);

          return settingsString;
      }

      void writeHeaderTo(csvFile &os) const
      {
          if (!xRanges.empty()) {
              for (const xRange &range : xRanges) {
                  os << range.label + " max";
                  os << range.label + " min";
              }
          }
          os << "Function Calls";
          os << "Solution Accuracy";
          os << "Normalization strategy";
          os << "Trans weight";
          os << "Rot weight";
          //        os << std::endl;
      }

      void writeSettingsTo(csvFile &os) const
      {
          if (!xRanges.empty()) {
              for (const xRange &range : xRanges) {
                  os << range.max;
                  os << range.min;
              }
          }
          os << numberOfFunctionCalls;
          os << solverAccuracy;
          os << normalizationStrategyStrings[normalizationStrategy] + "_"
                    + std::to_string(normalizationParameter);
          os << objectiveWeights.translational;
          os << objectiveWeights.rotational;
      }
  };

  inline bool operator==(const Settings &settings1, const Settings &settings2) noexcept
  {
      return settings1.numberOfFunctionCalls == settings2.numberOfFunctionCalls
             && settings1.xRanges == settings2.xRanges
             && settings1.solverAccuracy == settings2.solverAccuracy
             && settings1.objectiveWeights.translational
                    == settings2.objectiveWeights.translational;
  }

  inline void updateMeshWithOptimalVariables(const std::vector<double> &x, SimulationMesh &m)
  {
      assert(CrossSectionType::name == RectangularBeamDimensions::name);
      const double E = x[0];
      const double A = x[1];
      const double beamWidth = std::sqrt(A);
      const double beamHeight = beamWidth;

      const double J = x[2];
      const double I2 = x[3];
      const double I3 = x[4];
      for (EdgeIndex ei = 0; ei < m.EN(); ei++) {
          Element &e = m.elements[ei];
          e.setDimensions(CrossSectionType(beamWidth, beamHeight));
          e.setMaterial(ElementMaterial(e.material.poissonsRatio, E));
          e.J = J;
          e.I2 = I2;
          e.I3 = I3;
      }

      CoordType center_barycentric(1, 0, 0);
      CoordType interfaceEdgeMiddle_barycentric(0, 0.5, 0.5);
      CoordType movableVertex_barycentric((center_barycentric + interfaceEdgeMiddle_barycentric)
                                          * x[x.size() - 2]);

      CoordType patternCoord0 = CoordType(0, 0, 0);
      double bottomEdgeHalfSize = 0.03 / std::tan(M_PI / 3);
      CoordType interfaceNodePosition(0, -0.03, 0);
      CoordType patternBottomRight = interfaceNodePosition + CoordType(bottomEdgeHalfSize, 0, 0);
      CoordType patternBottomLeft = interfaceNodePosition - CoordType(bottomEdgeHalfSize, 0, 0);
      vcg::Triangle3<double> baseTriangle(patternCoord0, patternBottomLeft, patternBottomRight);
      CoordType baseTriangleMovableVertexPosition = baseTriangle.cP(0)
                                                        * movableVertex_barycentric[0]
                                                    + baseTriangle.cP(1)
                                                          * movableVertex_barycentric[1]
                                                    + baseTriangle.cP(2)
                                                          * movableVertex_barycentric[2];
      VectorType patternPlaneNormal(0, 0, 1);
      baseTriangleMovableVertexPosition = vcg::RotationMatrix(patternPlaneNormal,
                                                              vcg::math::ToRad(x[x.size() - 1]))
                                          * baseTriangleMovableVertexPosition;

      const int fanSize = 6;
      for (int rotationCounter = 0; rotationCounter < fanSize; rotationCounter++) {
          m.vert[2 * rotationCounter + 1].P() = vcg::RotationMatrix(patternPlaneNormal,
                                                                    vcg::math::ToRad(
                                                                        60.0 * rotationCounter))
                                                * baseTriangleMovableVertexPosition;
      }

      m.reset();
  }

  struct Results
  {
      std::string label{"EmptyLabel"};
      double time{-1};
      int numberOfSimulationCrashes{0};
      Settings settings;
      struct ObjectiveValues
      {
          double totalRaw;
          double total;
          std::vector<double> perSimulationScenario_rawTranslational;
          std::vector<double> perSimulationScenario_rawRotational;
          std::vector<double> perSimulationScenario_translational;
          std::vector<double> perSimulationScenario_rotational;
          std::vector<double> perSimulationScenario_total;
      } objectiveValue;
      //    std::vector<std::pair<std::string,double>> optimalXNameValuePairs;
      std::vector<std::pair<std::string, double>> optimalXNameValuePairs;
      std::vector<std::shared_ptr<SimulationJob>> fullPatternSimulationJobs;
      std::vector<std::shared_ptr<SimulationJob>> reducedPatternSimulationJobs;

      PatternGeometry baseTriangleFullPattern; //non-fanned,non-tiled full pattern
      vcg::Triangle3<double> baseTriangle;

      struct JsonKeys
      {
          inline static std::string filename{"OptimizationResults.json"};
          inline static std::string optimizationVariables{"OptimizationVariables"};
          inline static std::string baseTriangle{"BaseTriangle"};
          inline static std::string Label{"Label"};
          inline static std::string FullPatternLabel{"FullPatternLabel"};
          inline static std::string Settings{"OptimizationSettings"};
      };

      void save(const string &saveToPath, const bool shouldExportDebugFiles = false)
      {
          std::filesystem::create_directories(saveToPath);
          //clear directory
          for (const auto &entry : std::filesystem::directory_iterator(saveToPath))
              std::filesystem::remove_all(entry.path());

          //Save optimal X
          nlohmann::json json_optimizationResults;
          json_optimizationResults[JsonKeys::Label] = label;
          std::string jsonValue_optimizationVariables;
          for (const auto &optimalXNameValuePair : optimalXNameValuePairs) {
              jsonValue_optimizationVariables.append(optimalXNameValuePair.first + ",");
          }
          jsonValue_optimizationVariables.pop_back(); // for deleting the last comma
          json_optimizationResults[JsonKeys::optimizationVariables] = jsonValue_optimizationVariables;

          for (const auto &optimalXNameValuePair : optimalXNameValuePairs) {
              json_optimizationResults[optimalXNameValuePair.first] = optimalXNameValuePair.second;
          }
          //base triangle
          json_optimizationResults[JsonKeys::baseTriangle]
              = std::vector<double>{baseTriangle.cP0(0)[0],
                                    baseTriangle.cP0(0)[1],
                                    baseTriangle.cP0(0)[2],
                                    baseTriangle.cP1(0)[0],
                                    baseTriangle.cP1(0)[1],
                                    baseTriangle.cP1(0)[2],
                                    baseTriangle.cP2(0)[0],
                                    baseTriangle.cP2(0)[1],
                                    baseTriangle.cP2(0)[2]};
          baseTriangleFullPattern.save(std::filesystem::path(saveToPath).string());
          json_optimizationResults[JsonKeys::FullPatternLabel] = baseTriangleFullPattern.getLabel();
          ////Save to json file
          std::filesystem::path jsonFilePath(
              std::filesystem::path(saveToPath).append(JsonKeys::filename));
          std::ofstream jsonFile_optimizationResults(jsonFilePath.string());
          jsonFile_optimizationResults << json_optimizationResults;

          /*TODO: Refactor since the meshes are saved for each simulation scenario although they do not change*/
          //Save jobs and meshes for each simulation scenario

          if (shouldExportDebugFiles) {
              //Save the reduced and full patterns
              const std::filesystem::path simulationJobsPath(
                  std::filesystem::path(saveToPath).append("SimulationJobs"));
              const int numberOfSimulationJobs = fullPatternSimulationJobs.size();
              for (int simulationScenarioIndex = 0;
                   simulationScenarioIndex < numberOfSimulationJobs;
                   simulationScenarioIndex++) {
                  const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
                      = fullPatternSimulationJobs[simulationScenarioIndex];
                  std::filesystem::path simulationJobFolderPath(
                      std::filesystem::path(simulationJobsPath)
                          .append(pFullPatternSimulationJob->label));
                  std::filesystem::create_directories(simulationJobFolderPath);
                  const auto fullPatternDirectoryPath
                      = std::filesystem::path(simulationJobFolderPath).append("Full");
                  std::filesystem::create_directory(fullPatternDirectoryPath);
                  pFullPatternSimulationJob->save(fullPatternDirectoryPath.string());
                  const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob
                      = reducedPatternSimulationJobs[simulationScenarioIndex];
                  const auto reducedPatternDirectoryPath
                      = std::filesystem::path(simulationJobFolderPath).append("Reduced");
                  if (!std::filesystem::exists(reducedPatternDirectoryPath)) {
                      std::filesystem::create_directory(reducedPatternDirectoryPath);
                  }
                  pReducedPatternSimulationJob->save(reducedPatternDirectoryPath.string());
              }
          }

          settings.save(saveToPath);

#ifdef POLYSCOPE_DEFINED
          std::cout << "Saved optimization results to:" << saveToPath << std::endl;
#endif
      }

      bool load(const string &loadFromPath, const bool &shouldLoadDebugFiles = false)
      {
          assert(std::filesystem::is_directory(loadFromPath));
          std::filesystem::path jsonFilepath(
              std::filesystem::path(loadFromPath).append(JsonKeys::filename));
          if (!std::filesystem::exists(jsonFilepath)) {
              return false;
          }
          //Load optimal X
          nlohmann::json json_optimizationResults;
          std::ifstream ifs(std::filesystem::path(loadFromPath).append(JsonKeys::filename));
          ifs >> json_optimizationResults;

          label = json_optimizationResults.at(JsonKeys::Label);
          std::string optimizationVariablesString = *json_optimizationResults.find(
              JsonKeys::optimizationVariables);
          std::string optimizationVariablesDelimeter = ",";
          size_t pos = 0;
          std::vector<std::string> optimizationVariablesNames;
          while ((pos = optimizationVariablesString.find(optimizationVariablesDelimeter))
                 != std::string::npos) {
              const std::string variableName = optimizationVariablesString.substr(0, pos);
              optimizationVariablesNames.push_back(variableName);
              optimizationVariablesString.erase(0, pos + optimizationVariablesDelimeter.length());
          }
          optimizationVariablesNames.push_back(optimizationVariablesString); //add last variable name

          optimalXNameValuePairs.resize(optimizationVariablesNames.size());
          for (int xVariable_index = 0; xVariable_index < optimizationVariablesNames.size();
               xVariable_index++) {
              const std::string xVariable_name = optimizationVariablesNames[xVariable_index];
              const double xVariable_value = *json_optimizationResults.find(xVariable_name);
              optimalXNameValuePairs[xVariable_index] = std::make_pair(xVariable_name,
                                                                       xVariable_value);
          }

          const std::string fullPatternLabel = json_optimizationResults.at(
              JsonKeys::FullPatternLabel);
          baseTriangleFullPattern.load(
              std::filesystem::path(loadFromPath).append(fullPatternLabel + ".ply").string());

          std::vector<double> baseTriangleVertices = json_optimizationResults.at(
              JsonKeys::baseTriangle);
          baseTriangle.P0(0) = CoordType(baseTriangleVertices[0],
                                         baseTriangleVertices[1],
                                         baseTriangleVertices[2]);
          baseTriangle.P1(0) = CoordType(baseTriangleVertices[3],
                                         baseTriangleVertices[4],
                                         baseTriangleVertices[5]);
          baseTriangle.P2(0) = CoordType(baseTriangleVertices[6],
                                         baseTriangleVertices[7],
                                         baseTriangleVertices[8]);
          if (shouldLoadDebugFiles) {
              const std::filesystem::path simulationJobsFolderPath(
                  std::filesystem::path(loadFromPath).append("SimulationJobs"));
              for (const auto &directoryEntry :
                   filesystem::directory_iterator(simulationJobsFolderPath)) {
                  const auto simulationScenarioPath = directoryEntry.path();
                  if (!std::filesystem::is_directory(simulationScenarioPath)) {
                      continue;
                  }
                  // Load full pattern files
                  for (const auto &fileEntry : filesystem::directory_iterator(
                           std::filesystem::path(simulationScenarioPath).append("Full"))) {
                      const auto filepath = fileEntry.path();
                      if (filepath.extension() == ".json") {
                          SimulationJob job;

                          job.load(filepath.string());
                          fullPatternSimulationJobs.push_back(std::make_shared<SimulationJob>(job));
                      }
                  }

                  // Load reduced pattern files and apply optimal parameters
                  for (const auto &fileEntry : filesystem::directory_iterator(
                           std::filesystem::path(simulationScenarioPath).append("Reduced"))) {
                      const auto filepath = fileEntry.path();
                      if (filepath.extension() == ".json") {
                          SimulationJob job;
                          job.load(filepath.string());
                          applyOptimizationResults_innerHexagon(*this, baseTriangle, *job.pMesh);
                          applyOptimizationResults_elements(*this, job.pMesh);
                          reducedPatternSimulationJobs.push_back(
                              std::make_shared<SimulationJob>(job));
                      }
                  }
              }
          }
          settings.load(loadFromPath);

          return true;
      }

      template<typename MeshType>
      static void applyOptimizationResults_innerHexagon(
          const ReducedPatternOptimization::Results &reducedPattern_optimizationResults,
          const vcg::Triangle3<double> &patternBaseTriangle,
          MeshType &reducedPattern)
      {
          std::unordered_map<std::string, double>
              optimalXVariables(reducedPattern_optimizationResults.optimalXNameValuePairs.begin(),
                                reducedPattern_optimizationResults.optimalXNameValuePairs.end());
          assert(optimalXVariables.contains("HexSize") && optimalXVariables.contains("HexAngle"));
          applyOptimizationResults_innerHexagon(optimalXVariables.at("HexSize"),
                                                optimalXVariables.at("HexAngle"),
                                                patternBaseTriangle,
                                                reducedPattern);
      }

      template<typename MeshType>
      static void applyOptimizationResults_innerHexagon(
          const double &hexSize,
          const double &hexAngle,
          const vcg::Triangle3<double> &patternBaseTriangle,
          MeshType &reducedPattern)
      {
          //Set optimal geometrical params of the reduced pattern
          //          CoordType center_barycentric(1, 0, 0);
          //          CoordType interfaceEdgeMiddle_barycentric(0, 0.5, 0.5);
          //          CoordType movableVertex_barycentric(
          //              (center_barycentric * (1 - hexSize) + interfaceEdgeMiddle_barycentric));
          CoordType movableVertex_barycentric(1 - hexSize, hexSize / 2, hexSize / 2);

          reducedPattern.vert[0].P() = patternBaseTriangle.cP(0) * movableVertex_barycentric[0]
                                       + patternBaseTriangle.cP(1) * movableVertex_barycentric[1]
                                       + patternBaseTriangle.cP(2) * movableVertex_barycentric[2];
          if (hexAngle != 0) {
              reducedPattern.vert[0].P() = vcg::RotationMatrix(CoordType{0, 0, 1},
                                                               vcg::math::ToRad(hexAngle))
                                           * reducedPattern.vert[0].cP();
          }
          //          CoordType p0 = reducedPattern.vert[0].P();
          //          CoordType p1 = reducedPattern.vert[1].P();
          //          int i = 0;
          //          i++;
      }

      static void applyOptimizationResults_elements(
          const ReducedPatternOptimization::Results &reducedPattern_optimizationResults,
          const shared_ptr<SimulationMesh> &pTiledReducedPattern_simulationMesh)
      {
          assert(CrossSectionType::name == RectangularBeamDimensions::name);
          // Set reduced parameters fron the optimization results
          std::unordered_map<std::string, double>
              optimalXVariables(reducedPattern_optimizationResults.optimalXNameValuePairs.begin(),
                                reducedPattern_optimizationResults.optimalXNameValuePairs.end());

          const std::string ALabel = "A";
          assert(optimalXVariables.contains(ALabel));
          const double A = optimalXVariables.at(ALabel);
          const double beamWidth = std::sqrt(A);
          const double beamHeight = beamWidth;
          CrossSectionType elementDimensions(beamWidth, beamHeight);

          const double poissonsRatio = 0.3;
          const std::string ymLabel = "E";
          assert(optimalXVariables.contains(ymLabel));
          const double E = optimalXVariables.at(ymLabel);
          const ElementMaterial elementMaterial(poissonsRatio, E);

          const std::string JLabel = "J";
          assert(optimalXVariables.contains(JLabel));
          const double J = optimalXVariables.at(JLabel);

          const std::string I2Label = "I2";
          assert(optimalXVariables.contains(I2Label));
          const double I2 = optimalXVariables.at(I2Label);

          const std::string I3Label = "I3";
          assert(optimalXVariables.contains(I3Label));
          const double I3 = optimalXVariables.at(I3Label);
          for (int ei = 0; ei < pTiledReducedPattern_simulationMesh->EN(); ei++) {
              Element &e = pTiledReducedPattern_simulationMesh->elements[ei];
              e.setDimensions(elementDimensions);
              e.setMaterial(elementMaterial);
              e.J = J;
              e.I2 = I2;
              e.I3 = I3;
          }
          pTiledReducedPattern_simulationMesh->reset();
      }

#if POLYSCOPE_DEFINED
    void draw() const {
        PolyscopeInterface::init();
        DRMSimulationModel drmSimulator;
        LinearSimulationModel linearSimulator;
        assert(fullPatternSimulationJobs.size() == reducedPatternSimulationJobs.size());
        fullPatternSimulationJobs[0]->pMesh->registerForDrawing(Colors::fullInitial);
        reducedPatternSimulationJobs[0]->pMesh->registerForDrawing(Colors::reducedInitial, false);

        const int numberOfSimulationJobs = fullPatternSimulationJobs.size();
        for (int simulationJobIndex = 0; simulationJobIndex < numberOfSimulationJobs;
             simulationJobIndex++) {
            // Drawing of full pattern results
            const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
                = fullPatternSimulationJobs[simulationJobIndex];
            pFullPatternSimulationJob->registerForDrawing(
                fullPatternSimulationJobs[0]->pMesh->getLabel());
            SimulationResults fullModelResults = drmSimulator.executeSimulation(
                pFullPatternSimulationJob);
            fullModelResults.registerForDrawing(Colors::fullDeformed, true, true);
            //        SimulationResults fullModelLinearResults =
            //            linearSimulator.executeSimulation(pFullPatternSimulationJob);
            //        fullModelLinearResults.setLabelPrefix("linear");
            //        fullModelLinearResults.registerForDrawing(Colors::fullDeformed,false);
            // Drawing of reduced pattern results
            const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob
                = reducedPatternSimulationJobs[simulationJobIndex];
            //        SimulationResults reducedModelResults = drmSimulator.executeSimulation(
            //            pReducedPatternSimulationJob);
            //        reducedModelResults.registerForDrawing(Colors::reducedDeformed, false);
            SimulationResults reducedModelLinearResults = linearSimulator.executeSimulation(
                pReducedPatternSimulationJob);
            reducedModelLinearResults.setLabelPrefix("linear");
            reducedModelLinearResults.registerForDrawing(Colors::reducedDeformed, false);
            polyscope::options::programName = fullPatternSimulationJobs[0]->pMesh->getLabel();
            polyscope::view::resetCameraToHomeView();
            polyscope::show();
            // Save a screensh
            const std::string screenshotFilename
                = "/home/iason/Coding/Projects/Approximating shapes with flat "
                  "patterns/RodModelOptimizationForPatterns/Results/Images/"
                  + fullPatternSimulationJobs[0]->pMesh->getLabel() + "_"
                  + pFullPatternSimulationJob->getLabel();
            polyscope::screenshot(screenshotFilename, false);
            fullModelResults.unregister();
            //        reducedModelResults.unregister();
            reducedModelLinearResults.unregister();
            //        fullModelLinearResults.unregister();
            //                    double error = computeError(
            //                        reducedModelResults.displacements,fullModelResults.displacements,
            //                        );
            //                    std::cout << "Error of simulation scenario "
            //                              <<
            //                              simula         simulationScenarioStrings[simulationScenarioIndex]
            //                              << " is "
            //                              << error << std::endl;
      }
    }
#endif // POLYSCOPE_DEFINED
    void saveMeshFiles() const {
      const int numberOfSimulationJobs = fullPatternSimulationJobs.size();
      assert(numberOfSimulationJobs != 0 &&
             fullPatternSimulationJobs.size() ==
                 reducedPatternSimulationJobs.size());

      fullPatternSimulationJobs[0]->pMesh->save(
          "undeformed " + fullPatternSimulationJobs[0]->pMesh->getLabel() + ".ply");
      reducedPatternSimulationJobs[0]->pMesh->save(
          "undeformed " + reducedPatternSimulationJobs[0]->pMesh->getLabel() + ".ply");
      DRMSimulationModel simulator_drm;
      LinearSimulationModel simulator_linear;
      for (int simulationJobIndex = 0; simulationJobIndex < numberOfSimulationJobs;
           simulationJobIndex++) {
          // Drawing of full pattern results
          const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob
              = fullPatternSimulationJobs[simulationJobIndex];
          SimulationResults fullModelResults = simulator_drm.executeSimulation(
              pFullPatternSimulationJob);
          fullModelResults.saveDeformedModel();

          // Drawing of reduced pattern results
          const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob
              = reducedPatternSimulationJobs[simulationJobIndex];
          SimulationResults reducedModelResults = simulator_linear.executeSimulation(
              pReducedPatternSimulationJob);
          reducedModelResults.saveDeformedModel();
      }
    }

    void writeHeaderTo(csvFile &os)
    {
        os << "Total raw Obj value";
        os << "Total Obj value";
        for (int simulationScenarioIndex = 0;
             simulationScenarioIndex < fullPatternSimulationJobs.size();
             simulationScenarioIndex++) {
            const std::string simulationScenarioName
                = fullPatternSimulationJobs[simulationScenarioIndex]->getLabel();
            os << "Obj value Trans " + simulationScenarioName;
            os << "Obj value Rot " + simulationScenarioName;
            os << "Obj value Total " + simulationScenarioName;
        }
        for (const auto &nameValuePair : optimalXNameValuePairs) {
            os << nameValuePair.first;
        }
        os << "Time(s)";
        os << "#Crashes";
    }

    void writeResultsTo(const Settings &settings_optimization, csvFile &os) const
    {
        os << objectiveValue.totalRaw;
        os << objectiveValue.total;
        for (int simulationScenarioIndex = 0;
             simulationScenarioIndex < fullPatternSimulationJobs.size();
             simulationScenarioIndex++) {
            os << objectiveValue.perSimulationScenario_translational[simulationScenarioIndex];
            os << objectiveValue.perSimulationScenario_rotational[simulationScenarioIndex];
            os << objectiveValue.perSimulationScenario_total[simulationScenarioIndex];
        }
        for (const auto &optimalXNameValuePair : optimalXNameValuePairs) {
            os << optimalXNameValuePair.second;
        }

        os << time;
        if (numberOfSimulationCrashes == 0) {
            os << "-";
        } else {
            os << numberOfSimulationCrashes;
        }
    }
  };

  }    // namespace ReducedPatternOptimization
#endif // REDUCEDMODELOPTIMIZER_STRUCTS_HPP