#ifndef REDUCEDMODELOPTIMIZER_HPP
#define REDUCEDMODELOPTIMIZER_HPP

#include "csvfile.hpp"
#include "drmsimulationmodel.hpp"
#include "edgemesh.hpp"
#include "linearsimulationmodel.hpp"
#include "matplot/matplot.h"
#include "reducedmodeloptimizer_structs.hpp"
#include "simulationmesh.hpp"
#include <Eigen/Dense>

#ifdef POLYSCOPE_DEFINED
#include "polyscope/color_management.h"
#endif // POLYSCOPE_DEFINED
using FullPatternVertexIndex = VertexIndex;
using ReducedPatternVertexIndex = VertexIndex;

class ReducedModelOptimizer
{
    std::shared_ptr<SimulationMesh> m_pReducedPatternSimulationMesh;
    std::shared_ptr<SimulationMesh> m_pFullPatternSimulationMesh;
    std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
        m_fullToReducedInterfaceViMap;
    std::unordered_map<FullPatternVertexIndex, FullPatternVertexIndex>
        m_fullPatternOppositeInterfaceViMap;
    std::unordered_map<size_t, size_t> nodeToSlot;
    std::unordered_map<size_t, std::unordered_set<size_t>> slotToNode;
#ifdef POLYSCOPE_DEFINED
#endif // POLYSCOPE_DEFINED

public:
  inline static int fanSize{6};
  inline static VectorType patternPlaneNormal{0, 0, 1};
  ReducedModelOptimization::Results optimize(
      const ReducedModelOptimization::Settings &xRanges,
      const std::vector<ReducedModelOptimization::SimulationScenario> &simulationScenarios
      = std::vector<ReducedModelOptimization::SimulationScenario>());
  double operator()(const Eigen::VectorXd &x, Eigen::VectorXd &) const;

  ReducedModelOptimizer(const std::vector<size_t> &numberOfNodesPerSlot);
  static void computeReducedModelSimulationJob(
      const SimulationJob &simulationJobOfFullModel,
      const std::unordered_map<size_t, size_t> &fullToReducedMap,
      SimulationJob &simulationJobOfReducedModel);

  SimulationJob
  getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);

  void initializePatterns(PatternGeometry &fullPattern, PatternGeometry &reducedPatterm,
      const std::unordered_set<size_t> &reducedModelExcludedEges, const int &optimizationParameters);

  static void runSimulation(const std::string &filename,
                            std::vector<double> &x);

  static double objective(double x2, double A, double J, double I2, double I3, double x3,
                          double innerHexagonRotationAngle);
  static double objective(double b, double r, double E);

  static std::vector<std::shared_ptr<SimulationJob>>
    createScenarios(const std::shared_ptr<SimulationMesh> &pMesh,
                    const std::unordered_map<size_t, size_t>
                        &fullPatternOppositeInterfaceViMap);

  static void createSimulationMeshes(
      PatternGeometry &fullModel, PatternGeometry &reducedModel,
      std::shared_ptr<SimulationMesh> &pFullPatternSimulationMesh,
      std::shared_ptr<SimulationMesh> &pReducedPatternSimulationMesh);
  static void computeMaps(
      const std::unordered_set<size_t> &reducedModelExcludedEdges,
      const std::unordered_map<size_t, std::unordered_set<size_t>> &slotToNode,
      PatternGeometry &fullPattern, PatternGeometry &reducedPattern,
      std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
          &reducedToFullInterfaceViMap,
      std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
          &fullToReducedInterfaceViMap,
      std::unordered_map<FullPatternVertexIndex, ReducedPatternVertexIndex>
          &fullPatternOppositeInterfaceViMap);
  static void visualizeResults(
      const std::vector<std::shared_ptr<SimulationJob>> &fullPatternSimulationJobs,
      const std::vector<std::shared_ptr<SimulationJob>> &reducedPatternSimulationJobs,
      const std::vector<ReducedModelOptimization::SimulationScenario> &simulationScenarios,
      const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
          &reducedToFullInterfaceViMap);
  static void registerResultsForDrawing(
      const std::shared_ptr<SimulationJob> &pFullPatternSimulationJob,
      const std::shared_ptr<SimulationJob> &pReducedPatternSimulationJob,
      const std::unordered_map<ReducedPatternVertexIndex,
                               FullPatternVertexIndex>
          &reducedToFullInterfaceViMap);

  static double computeRawDisplacementError(
      const std::vector<Vector6d> &reducedPatternDisplacements,
      const std::vector<Vector6d> &fullPatternDisplacements,
      const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
          &reducedToFullInterfaceViMap);

  static double computeDisplacementError(
      const std::vector<Vector6d> &reducedPatternDisplacements,
      const std::vector<Vector6d> &fullPatternDisplacements,
      const std::unordered_map<ReducedPatternVertexIndex, FullPatternVertexIndex>
          &reducedToFullInterfaceViMap,
      const double &normalizationFactor);

  static double objective(double E, double A, double innerHexagonSize, double innerHexagonRotationAngle);
  private:
      static void computeDesiredReducedModelDisplacements(
          const SimulationResults &fullModelResults,
          const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
          Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
      static ReducedModelOptimization::Results runOptimization(
          const ReducedModelOptimization::Settings &settings);
      std::vector<std::shared_ptr<SimulationJob>> createScenarios(
          const std::shared_ptr<SimulationMesh> &pMesh);
      void computeMaps(PatternGeometry &fullModel,
                       PatternGeometry &reducedPattern,
                       const std::unordered_set<size_t> &reducedModelExcludedEges);
      void createSimulationMeshes(PatternGeometry &fullModel, PatternGeometry &reducedModel);
      static void initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh,
                                                   const int &optimizationParamters);

      static double objective(long n, const double *x);
      DRMSimulationModel simulator;
      void computeObjectiveValueNormalizationFactors();
};
void updateMesh(long n, const double *x);
#endif // REDUCEDMODELOPTIMIZER_HPP