#ifndef REDUCEDMODELOPTIMIZER_HPP
#define REDUCEDMODELOPTIMIZER_HPP

#include "beamformfinder.hpp"
#include "edgemesh.hpp"
#include "elementalmesh.hpp"
#include "matplot/matplot.h"
#include <Eigen/Dense>

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;
  std::vector<double> initialGuess;

public:
  enum SimulationScenario {
    Axial,
    Shear,
    Bending,
    Dome,
    Saddle,
    NumberOfSimulationScenarios
  };
  struct Results {
    int numberOfSimulationCrashes{0};
    std::vector<double> x;
    double objectiveValue;
  };
  struct xRange {
    std::string label;
    double min;
    double max;
    std::string toString() const {
      return label + "=[" + std::to_string(min) + "," + std::to_string(max) +
             "]";
    }
  };

  struct Settings {
    std::vector<xRange> xRanges;
    int maxSimulations{100};
    double solutionAccuracy{1e-5};
  };

  inline static const std::string simulationScenarioStrings[] = {
      "Axial", "Shear", "Bending", "Double", "Saddle"};
  Results optimize(const Settings &xRanges,
                   const std::vector<SimulationScenario> &simulationScenarios =
                       std::vector<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> &simulationJobFullToReducedMap,
      SimulationJob &simulationJobOfReducedModel);

  SimulationJob
  getReducedSimulationJob(const SimulationJob &fullModelSimulationJob);

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

  void setInitialGuess(std::vector<double> v);

  static void runBeamOptimization();

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

  static double objective(double x0, double x1, double x2, double x3);
  static double objective(double b, double h, double E);

private:
  void
  visualizeResults(const std::vector<std::shared_ptr<SimulationJob>>
                       &fullPatternSimulationJobs,
                   const std::vector<SimulationScenario> &simulationScenarios);
  static void computeDesiredReducedModelDisplacements(
      const SimulationResults &fullModelResults,
      const std::unordered_map<size_t, size_t> &displacementsReducedToFullMap,
      Eigen::MatrixX3d &optimalDisplacementsOfReducedModel);
  static Results runOptimization(const Settings &settings,
                                 double (*pObjectiveFunction)(long,
                                                              const double *));
  std::vector<std::shared_ptr<SimulationJob>>
  createScenarios(const std::shared_ptr<SimulationMesh> &pMesh);
  void computeMaps(FlatPattern &fullModel, FlatPattern &reducedPattern,
                   const std::unordered_set<size_t> &reducedModelExcludedEges);
  void createSimulationMeshes(FlatPattern &fullModel,
                              FlatPattern &reducedModel);
  static void
  initializeOptimizationParameters(const std::shared_ptr<SimulationMesh> &mesh);

  static double
  computeError(const SimulationResults &reducedPatternResults,
               const Eigen::MatrixX3d &optimalReducedPatternDisplacements);
  static double objective(long n, const double *x);
};

#endif // REDUCEDMODELOPTIMIZER_HPP