#ifndef UTILITIES_H
#define UTILITIES_H

#include <Eigen/Dense>
#include <algorithm>
#include <array>
#include <chrono>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <numeric>
#include <regex>

#define GET_VARIABLE_NAME(Variable) (#Variable)

struct Vector6d : public std::array<double, 6> {
  Vector6d() {
    for (size_t i = 0; i < 6; i++) {
      this->operator[](i) = 0;
    }
  }

  Vector6d(const std::vector<double> &v) {
    assert(v.size() == 6);
    std::copy(v.begin(), v.end(), this->begin());
  }

  Vector6d(const double &d) {
    for (size_t i = 0; i < 6; i++) {
      this->operator[](i) = d;
    }
  }

  Vector6d(const std::array<double, 6> &arr) : std::array<double, 6>(arr) {}

  Vector6d(const std::initializer_list<double> &initList) {
    std::copy(initList.begin(), initList.end(), std::begin(*this));
  }

  Vector6d operator*(const double &d) const {
    Vector6d result;
    for (size_t i = 0; i < 6; i++) {
      result[i] = this->operator[](i) * d;
    }
    return result;
  }

  Vector6d operator*(const Vector6d &v) const {
    Vector6d result;
    for (size_t i = 0; i < 6; i++) {
      result[i] = this->operator[](i) * v[i];
    }
    return result;
  }

  Vector6d operator/(const double &d) const {
    Vector6d result;
    for (size_t i = 0; i < 6; i++) {
      result[i] = this->operator[](i) / d;
    }
    return result;
  }

  Vector6d operator/(const Vector6d &v) const
  {
      Vector6d result;
      for (size_t i = 0; i < 6; i++) {
          result[i] = this->operator[](i) / v[i];
      }
      return result;
  }

  Vector6d operator+(const Vector6d &v) const {
    Vector6d result;
    for (size_t i = 0; i < 6; i++) {
      result[i] = this->operator[](i) + v[i];
    }
    return result;
  }

  Vector6d operator-(const Vector6d &v) const {
    Vector6d result;
    for (size_t i = 0; i < 6; i++) {
      result[i] = this->operator[](i) - v[i];
    }
    return result;
  }

  Vector6d inverted() const {
    Vector6d result;
    for (size_t i = 0; i < 6; i++) {
      assert(this->operator[](i) != 0);
      result[i] = 1 / this->operator[](i);
    }
    return result;
  }
  bool isZero() const {
    for (size_t i = 0; i < 6; i++) {
      if (this->operator[](i) != 0)
        return false;
    }
    return true;
  }

  double squaredNorm() const {
    double squaredNorm = 0;
    std::for_each(this->begin(), std::end(*this),
                  [&](const double &v) { squaredNorm += pow(v, 2); });
    return squaredNorm;
  }

  double norm() const { return sqrt(squaredNorm()); }

  bool isFinite() const {
    return std::any_of(std::begin(*this), std::end(*this), [](const double &v) {
      if (!std::isfinite(v)) {
        return false;
      }
      return true;
    });
  }

  Eigen::Vector3d getTranslation() const {
    return Eigen::Vector3d(this->operator[](0), this->operator[](1),
                           this->operator[](2));
  }

  Eigen::Vector3d getRotation() const
  {
      return Eigen::Vector3d(this->operator[](3), this->operator[](4), this->operator[](5));
  }

  std::string toString() const
  {
      std::string s;
      for (int i = 0; i < 6; i++) {
          s.append(std::to_string(this->operator[](i)) + ",");
      }
      s.pop_back();
      return s;
  }
};

namespace Utilities {
inline bool compareNat(const std::string &a, const std::string &b)
{
    if (a.empty())
        return true;
    if (b.empty())
        return false;
    if (std::isdigit(a[0]) && !std::isdigit(b[0]))
        return true;
    if (!std::isdigit(a[0]) && std::isdigit(b[0]))
        return false;
    if (!std::isdigit(a[0]) && !std::isdigit(b[0])) {
        if (std::toupper(a[0]) == std::toupper(b[0]))
            return compareNat(a.substr(1), b.substr(1));
        return (std::toupper(a[0]) < std::toupper(b[0]));
    }

    // Both strings begin with digit --> parse both numbers
    std::istringstream issa(a);
    std::istringstream issb(b);
    int ia, ib;
    issa >> ia;
    issb >> ib;
    if (ia != ib)
        return ia < ib;

    // Numbers are the same --> remove numbers and recurse
    std::string anew, bnew;
    std::getline(issa, anew);
    std::getline(issb, bnew);
    return (compareNat(anew, bnew));
}

inline std::string_view leftTrimSpaces(const std::string_view& str)
{
std::string_view trimmedString=str;
    const auto pos(str.find_first_not_of(" \t\n\r\f\v"));
    trimmedString.remove_prefix(std::min(pos, trimmedString.length()));
    return trimmedString;
}

inline std::string_view rightTrimSpaces(const std::string_view& str)
{
std::string_view trimmedString=str;
    const auto pos(trimmedString.find_last_not_of(" \t\n\r\f\v"));
    trimmedString.remove_suffix(std::min(trimmedString.length() - pos - 1,trimmedString.length()));
    return trimmedString;
}

inline std::string_view trimLeftAndRightSpaces(std::string_view str)
{
std::string_view trimmedString=str;
    trimmedString = leftTrimSpaces(trimmedString);
    trimmedString = rightTrimSpaces(trimmedString);
    return trimmedString;
}

template<typename InputIt>
inline void normalize(InputIt itBegin, InputIt itEnd)
{
    const auto squaredSumOfElements = std::accumulate(itBegin,
                                                      itEnd,
                                                      0.0,
                                                      [](const auto &sum, const auto &el) {
                                                          return sum + el * el;
                                                      });
    assert(squaredSumOfElements != 0);
    std::transform(itBegin, itEnd, itBegin, [&](auto &element) {
        return element / std::sqrt(squaredSumOfElements);
    });
}

inline std::vector<std::string> split(const std::string& text, std::string delim)
{
    std::vector<std::string> vec;
    size_t pos = 0, prevPos = 0;
    while (1) {
        pos = text.find(delim, prevPos);
        if (pos == std::string::npos) {
            vec.push_back(text.substr(prevPos));
            return vec;
        }

        vec.push_back(text.substr(prevPos, pos - prevPos));
        prevPos = pos + delim.length();
    }
}

inline std::string toString(const std::vector<std::vector<int>> &vv)
{
    std::string s;
    s.append("{");
    for (const std::vector<int> &v : vv) {
        s.append("{");
        for (const int &i : v) {
            s.append(std::to_string(i) + ",");
        }
        s.pop_back();
        s.append("}");
    }
    s.append("}");
    return s;
}
inline void parseIntegers(const std::string &str, std::vector<size_t> &result)
{
    typedef std::regex_iterator<std::string::const_iterator> re_iterator;
    typedef re_iterator::value_type re_iterated;

    std::regex re("(\\d+)");

    re_iterator rit(str.begin(), str.end(), re);
    re_iterator rend;

    std::transform(rit, rend, std::back_inserter(result), [](const re_iterated &it) {
        return std::stoi(it[1]);
    });
}

inline Eigen::MatrixXd toEigenMatrix(const std::vector<Vector6d> &v) {
    Eigen::MatrixXd m(v.size(), 6);

    for (size_t vi = 0; vi < v.size(); vi++) {
        const Vector6d &vec = v[vi];
        for (size_t i = 0; i < 6; i++) {
            m(vi, i) = vec[i];
        }
  }

  return m;
}

inline std::vector<Vector6d> fromEigenMatrix(const Eigen::MatrixXd &m)
{
    std::vector<Vector6d> v(m.rows());

    for (size_t vi = 0; vi < m.rows(); vi++) {
        const Eigen::RowVectorXd &row = m.row(vi);
        for (size_t i = 0; i < 6; i++) {
            v[vi][i] = row(i);
        }
    }

    return v;
}
// std::string convertToLowercase(const std::string &s) {
//  std::string lowercase;
//  std::transform(s.begin(), s.end(), lowercase.begin(),
//                 [](unsigned char c) { return std::tolower(c); });
//  return lowercase;
//}
// bool hasExtension(const std::string &filename, const std::string &extension)
// {
//  const std::filesystem::path path(filename);
//  if (!path.has_extension()) {
//    std::cerr << "Error: No file extension found in " << filename <<
//    std::endl; return false;
//  }

//  const std::string detectedExtension = path.extension().string();

//  if (convertToLowercase(detectedExtension) != convertToLowercase(extension))
//  {
//    std::cerr << "Error: detected extension is " + detectedExtension +
//                     " and not " + extension
//              << std::endl;
//    return false;
//  }
//  return true;
//}

inline std::filesystem::path getFilepathWithExtension(const std::filesystem::path &folderPath,
                                                      const std::string &extension)
{
    for (const std::filesystem::directory_entry &dirEntry :
         std::filesystem::directory_iterator(folderPath)) {
        if (dirEntry.is_regular_file() && std::filesystem::path(dirEntry).extension() == extension) {
            return std::filesystem::path(dirEntry);
        }
    }

    return "";
}

} // namespace Utilities

#ifdef POLYSCOPE_DEFINED
#include "polyscope/curve_network.h"
#include "polyscope/pick.h"
#include "polyscope/polyscope.h"
#include <functional>

namespace PolyscopeInterface {
inline struct GlobalPolyscopeData
{
    std::vector<std::function<void()>> userCallbacks;
} globalPolyscopeData;

inline void mainCallback()
{
    ImGui::PushItemWidth(100); // Make ui elements 100 pixels wide,
                               // instead of full width. Must have
                               // matching PopItemWidth() below.

    for (std::function<void()> &userCallback : globalPolyscopeData.userCallbacks) {
        userCallback();
    }

    ImGui::PopItemWidth();
}

inline void addUserCallback(const std::function<void()> &userCallback)
{
    globalPolyscopeData.userCallbacks.push_back(userCallback);
}

inline void deinitPolyscope()
{
    if (!polyscope::state::initialized) {
        return;
    }

    polyscope::render::engine->shutdownImGui();
}

inline void init()
{
    if (polyscope::state::initialized) {
        return;
    }
    polyscope::init();
    polyscope::options::groundPlaneEnabled = false;
    polyscope::view::upDir = polyscope::view::UpDir::ZUp;

    polyscope::state::userCallback = &mainCallback;
    polyscope::options::autocenterStructures = false;
    polyscope::options::autoscaleStructures = false;
}
using PolyscopeLabel = std::string;
inline std::pair<PolyscopeLabel, size_t> getSelection()
{
    std::pair<polyscope::Structure *, size_t> selection = polyscope::pick::getSelection();
    if (selection.first == nullptr) {
        return std::make_pair(std::string(), 0);
    }
    return std::make_pair(selection.first->name, selection.second);
}

inline void registerWorldAxes()
{
    PolyscopeInterface::init();

    Eigen::MatrixX3d axesPositions(4, 3);
    axesPositions.row(0) = Eigen::Vector3d(0, 0, 0);
    //    axesPositions.row(1) = Eigen::Vector3d(polyscope::state::lengthScale, 0, 0);
    //    axesPositions.row(2) = Eigen::Vector3d(0, polyscope::state::lengthScale, 0);
    //    axesPositions.row(3) = Eigen::Vector3d(0, 0, polyscope::state::lengthScale);
    axesPositions.row(1) = Eigen::Vector3d(1, 0, 0);
    axesPositions.row(2) = Eigen::Vector3d(0, 1, 0);
    axesPositions.row(3) = Eigen::Vector3d(0, 0, 1);

    Eigen::MatrixX2i axesEdges(3, 2);
    axesEdges.row(0) = Eigen::Vector2i(0, 1);
    axesEdges.row(1) = Eigen::Vector2i(0, 2);
    axesEdges.row(2) = Eigen::Vector2i(0, 3);
    Eigen::MatrixX3d axesColors(3, 3);
    axesColors.row(0) = Eigen::Vector3d(1, 0, 0);
    axesColors.row(1) = Eigen::Vector3d(0, 1, 0);
    axesColors.row(2) = Eigen::Vector3d(0, 0, 1);

    const std::string worldAxesName = "World Axes";
    polyscope::registerCurveNetwork(worldAxesName, axesPositions, axesEdges);
    polyscope::getCurveNetwork(worldAxesName)->setRadius(0.0001, false);
    const std::string worldAxesColorName = worldAxesName + " Color";
    polyscope::getCurveNetwork(worldAxesName)
        ->addEdgeColorQuantity(worldAxesColorName, axesColors)
        ->setEnabled(true);
}
} // namespace PolyscopeInterface

#endif

// namespace ConfigurationFile {

//}
//} // namespace ConfigurationFile
template <typename T1, typename T2>
void constructInverseMap(const T1 &map, T2 &oppositeMap) {
  assert(!map.empty());
  oppositeMap.clear();
  for (const auto &mapIt : map) {
    oppositeMap[mapIt.second] = mapIt.first;
  }
}

template <typename T> std::string toString(const T &v) {
  return "(" + std::to_string(v[0]) + "," + std::to_string(v[1]) + "," +
         std::to_string(v[2]) + ")";
}

template<typename T>
std::string to_string_with_precision(const T a_value, const int n = 2)
{
    std::ostringstream out;
    out.precision(n);
    out << std::fixed << a_value;
    return out.str();
}

template<typename T>
size_t computeHashUnordered(const std::vector<T> &v)
{
    size_t hash = 0;
    for (const auto &el : v) {
        hash += std::hash<T>{}(el);
    }
    return hash;
}

inline size_t computeHashOrdered(const std::vector<int> &v)
{
    std::string elementsString;
    for (const auto &el : v) {
        elementsString += std::to_string(el);
    }

    return std::hash<std::string>{}(elementsString);
}

#endif // UTILITIES_H