#ifndef SRC_SPATIAL_SOLVING_FIXEDPOINTITERATOR_HH
#define SRC_SPATIAL_SOLVING_FIXEDPOINTITERATOR_HH

#include <memory>

#include <dune/common/parametertree.hh>
#include <dune/common/bitsetvector.hh>

#include <dune/solvers/norms/norm.hh>
#include <dune/solvers/solvers/solver.hh>

#include <dune/fufem/boundarypatch.hh>

#include <dune/contact/assemblers/nbodyassembler.hh>

struct FixedPointIterationCounter {
  size_t iterations = 0;
  size_t multigridIterations = 0;

  void operator+=(FixedPointIterationCounter const &other);
};

std::ostream &operator<<(std::ostream &stream,
                         FixedPointIterationCounter const &fpic);

template <class Factory, class NBodyAssembler, class Updaters, class ErrorNorm>
class FixedPointIterator {
  using Functional = typename Factory::Functional;
  using ScalarVector = typename Updaters::StateUpdater::ScalarVector;
  using Vector = typename Factory::Vector;
  using Matrix = typename Factory::Matrix;
  using Nonlinearity = typename Factory::Functional::Nonlinearity;

  const static int dims = Vector::block_type::dimension;

 // using Nonlinearity = typename ConvexProblem::NonlinearityType;
 //  using DeformedGrid = typename Factory::DeformedGrid;

public:
  using GlobalFriction = Nonlinearity;
  using BitVector = Dune::BitSetVector<1>;

private:
  void relativeVelocities(const Vector& v, std::vector<Vector>& v_rel) const;

public:
  FixedPointIterator(const Dune::ParameterTree& parset,
                     NBodyAssembler& nBodyAssembler,
                     GlobalFriction& globalFriction,
                     const std::vector<const BitVector*>& bodywiseNonmortarBoundaries,
                     const std::vector<const ErrorNorm* >& errorNorms);

  FixedPointIterationCounter run(Updaters updaters,
                                 const std::vector<Matrix>& velocityMatrices,
                                 const std::vector<Vector>& velocityRHSs,
                                 std::vector<Vector>& velocityIterates);

private:
  const Dune::ParameterTree& parset_;
  NBodyAssembler& nBodyAssembler_;
  GlobalFriction& globalFriction_;
  const std::vector<const BitVector*>& bodywiseNonmortarBoundaries_;


  size_t fixedPointMaxIterations_;
  double fixedPointTolerance_;
  double lambda_;
  size_t velocityMaxIterations_;
  double velocityTolerance_;
  Solver::VerbosityMode verbosity_;
  const std::vector<const ErrorNorm* >& errorNorms_;
};
#endif