#pragma once

namespace AMDiS
{
  template <class ElementAssembler, class IntersectionAssembler, class BoundaryAssembler>
  struct AssemblerTriple
  {
    ElementAssembler elementAssembler;
    IntersectionAssembler intersectionAssembler;
    BoundaryAssembler boundaryAssembler;
  };

  template <class EA, class IA, class BA>
  AssemblerTriple<EA, IA, BA> makeAssemblerTriple(EA const& ea, IA const& ia, BA const& ba)
  {
    return {ea, ia, ba};
  }


  template <class GridView, class Element, class Operators, class EA, class IA, class BA>
  void assembleOperators(
      GridView const& gridView,
      Element const& element,
      Operators& operators,
      AssemblerTriple<EA,IA,BA> const& assemblerTriple)
  {
    // assemble element operators
    assemblerTriple.elementAssembler(element, operators.onElement());

    // assemble intersection operators
    if (!operators.onIntersection().empty()
        || (!operators.onBoundary().empty() && element.hasBoundaryIntersections()))
    {
      for (auto const& intersection : intersections(gridView, element)) {
        if (intersection.boundary())
          assemblerTriple.boundaryAssembler(intersection, operators.onBoundary());
        else
          assemblerTriple.intersectionAssembler(intersection, operators.onIntersection());
      }
    }
  }


  template <class Node, class ElementVector>
  auto makeVectorAssembler(Node const& node, ElementVector& elementVector)
  {
    return makeAssemblerTriple(
      [&](auto const& element, auto& operators) {
        for (auto op : operators)
          op->assemble(element, node, elementVector);
      },
      [&](auto const& is, auto& operators) {
        for (auto op : operators)
          op->assemble(is, node, elementVector);
      },
      [&](auto const& bis, auto& operators) {
        for (auto data : operators) {
          if (data.bc.onBoundary(bis))
            data.op->assemble(bis, node, elementVector);
        }
      });
  }


  template <class RowNode, class ColNode, class ElementMatrix>
  auto makeMatrixAssembler(RowNode const& rowNode, ColNode const& colNode, ElementMatrix& elementMatrix)
  {
    return makeAssemblerTriple(
      [&](auto const& element, auto& operators) {
        for (auto op : operators)
          op->assemble(element, rowNode, colNode, elementMatrix);
      },
      [&](auto const& is, auto& operators) {
        for (auto op : operators)
          op->assemble(is, rowNode, colNode, elementMatrix);
      },
      [&](auto const& bis, auto& operators) {
        for (auto data : operators) {
          if (data.bc.onBoundary(bis))
            data.op->assemble(bis, rowNode, colNode, elementMatrix);
        }
      });
  }

} // end namespace AMDiS