#pragma once

#include <memory>

#include <Eigen/IterativeLinearSolvers>
#include <Eigen/MetisSupport>
#include <Eigen/SparseLU>
#include <Eigen/SuperLUSupport>
#include <Eigen/UmfPackSupport>
#include <unsupported/Eigen/IterativeSolvers>

#include <amdis/CreatorMap.hpp>
#include <amdis/Initfile.hpp>
#include <amdis/Output.hpp>

#include <amdis/linearalgebra/LinearSolver.hpp>
#include <amdis/linearalgebra/eigen/DirectRunner.hpp>
#include <amdis/linearalgebra/eigen/IterativeRunner.hpp>
#include <amdis/linearalgebra/eigen/Traits.hpp>

namespace AMDiS
{
  template <class Mat, class Vec, template <class> class IterativeSolver>
  struct IterativeSolverCreator
      : public CreatorInterfaceName<LinearSolverInterface<Mat,Vec>>
  {
    template <class Precon>
    using SolverCreator
      = typename LinearSolver<Mat,Vec, IterativeRunner<Mat, Vec, IterativeSolver<Precon>>>::Creator;

    using SolverBase = LinearSolverInterface<Mat,Vec>;
    using M = typename Mat::BaseMatrix;
    using Scalar = typename M::Scalar;

    std::unique_ptr<SolverBase> createWithString(std::string prefix) override
    {
      // get creator string for preconditioner
      std::string precon = "no";
      Parameters::get(prefix + "->precon->name", precon);

      if (precon == "diag" ||
          precon == "jacobi")
      {
        auto creator = SolverCreator<Eigen::DiagonalPreconditioner<Scalar>>{};
        return creator.createWithString(prefix);
      }
      else if (precon == "ilu")
      {
        auto creator = SolverCreator<Eigen::IncompleteLUT<Scalar>>{};
        return creator.createWithString(prefix);
      }
      else if (precon == "ic")
      {
        return createIncompleteCholesky(prefix);
      }
      else {
        auto creator = SolverCreator<Eigen::IdentityPreconditioner>{};
        return creator.createWithString(prefix);
      }
    }


    template <class Ordering>
    using IncompleteCholesky =
      SolverCreator<Eigen::IncompleteCholesky<Scalar, Eigen::Lower|Eigen::Upper, Ordering>>;

    std::unique_ptr<SolverBase> createIncompleteCholesky(std::string prefix) const
    {
      std::string ordering = "amd";
      Parameters::get(prefix + "->precon->ordering", ordering);

      if (ordering == "amd") {
        using AMD = Eigen::AMDOrdering<typename M::StorageIndex>;
        return IncompleteCholesky<AMD>{}.createWithString(prefix);
      }
      else {
        using NATURAL = Eigen::NaturalOrdering<typename M::StorageIndex>;
        return IncompleteCholesky<NATURAL>{}.createWithString(prefix);
      }
    }
  };

  /// Adds default creators for linear solvers based on `Eigen::SparseMatrix`.
  /**
   * Adds creators for full-matrix aware solvers.
   * - *cg*: conjugate gradient method, \see Eigen::ConjugateGradient
   * - *bcgs*: stabilized bi-conjugate gradient method, \see Eigen::BiCGSTAB
   * - *minres*: Minimal Residual Algorithm (for symmetric matrices), \see Eigen::MINRES
   * - *gmres*: Generalized Minimal Residual Algorithm, \see Eigen::GMRES
   * - *dgmres*: stabilized bi-conjugate gradient method, \see Eigen::DGMRES
   * - *umfpack*: external UMFPACK solver, \see Eigen::UmfPackLU
   * - *superlu*: external SparseLU solver, \see Eigen::SparseLU
   **/
  template <class Mat, class Vec>
  class DefaultCreators< LinearSolverInterface<Mat,Vec> >
  {
    using SolverBase = LinearSolverInterface<Mat,Vec>;
    using M = typename Mat::BaseMatrix;

    template <template <class> class IterativeSolver>
    using SolverCreator
      = IterativeSolverCreator<Mat, Vec, IterativeSolver>;

    template <template <class> class DirectSolver>
    struct RunnerCreator
    {
      template <class M, class V>
      using Impl = DirectRunner<M, V, DirectSolver>;
    };

    template <template <class> class DirectSolver>
    using DirectSolverCreator
      = typename LinearSolver<Mat, Vec, DirectRunner<Mat, Vec, DirectSolver>>::Creator;

    //@{
    template <class Precon>
    using CG = Eigen::ConjugateGradient<M, Eigen::Lower|Eigen::Upper, Precon>;

    template <class Precon>
    using BCGS = Eigen::BiCGSTAB<M, Precon>;

    template <class Precon>
    using MINRES = Eigen::MINRES<M, Eigen::Lower|Eigen::Upper, Precon>;

    template <class Precon>
    using GMRES = Eigen::GMRES<M, Precon>;

    template <class Precon>
    using DGMRES = Eigen::DGMRES<M, Precon>;
    // @}

    using Map = CreatorMap<SolverBase>;

  public:
    static void init()
    {
      // conjugate gradient solver
      auto cg = new SolverCreator<CG>;
      Map::addCreator("cg", cg);

      // bi-conjugate gradient stabilized solver
      auto bicgstab = new SolverCreator<BCGS>;
      Map::addCreator("bicgstab", bicgstab);
      Map::addCreator("bcgs", bicgstab);

      // Minimal Residual Algorithm (for symmetric matrices)
      auto minres = new SolverCreator<MINRES>;
      Map::addCreator("minres", minres);

      // Generalized Minimal Residual Algorithm
      auto gmres = new SolverCreator<GMRES>;
      Map::addCreator("gmres", gmres);

      // Restarted GMRES with deflation.
      auto dgmres = new SolverCreator<DGMRES>;
      Map::addCreator("dgmres", dgmres);

      // default iterative solver
      Map::addCreator("default", gmres);

      init_direct(std::is_same<typename Dune::FieldTraits<typename M::Scalar>::real_type, double>{});
    }

    static void init_direct(std::false_type) {}
    static void init_direct(std::true_type)
    {
#if HAVE_SUITESPARSE_UMFPACK
      // sparse LU factorization and solver based on UmfPack
      auto umfpack = new DirectSolverCreator<Eigen::UmfPackLU>;
      Map::addCreator("umfpack", umfpack);
#endif

#if HAVE_SUPERLU
      // sparse direct LU factorization and solver based on the SuperLU library
      auto superlu = new DirectSolverCreator<Eigen::SuperLU>;
      Map::addCreator("superlu", superlu);
#endif

      // default direct solvers
#if HAVE_SUITESPARSE_UMFPACK
      Map::addCreator("direct", umfpack);
#elif HAVE_SUPERLU
      Map::addCreator("direct", superlu);
#endif
    }
  };

} // end namespace AMDiS