/**
 * @file   mg.cpp
 * @author Julian Iseringhausen <isering@ins.uni-bonn.de>
 * @date   Sat Jun 12 20:36:24 2010
 *
 * @brief  A multigrid solver
 *
 * This file contains the implementation of the main class for
 * a multigrid solver.
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <cmath>
#include <cstdio>
#include <cfloat>
#include <ctime>
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>

#include "base/command_list.hpp"
#include "base/discretization.hpp"
#include "base/factory.hpp"
#include "comm/comm.hpp"
#include "grid/tempgrid.hpp"
#include "interface/interface.hpp"
#include "level/level_operator.hpp"
#include "smoother/smoother.hpp"
#include "solver/solver.hpp"
#include "mg.hpp"

using namespace VMG;

#define REGISTER_COMMAND(a) extern void Initialize##a();Initialize##a();

Factory MG::factory;

static void VMGRegisterBuiltinCommands()
{
  REGISTER_COMMAND(VMGCommandCheckConsistency);
  REGISTER_COMMAND(VMGCommandCheckIterationCounter);
  REGISTER_COMMAND(VMGCommandCheckRelativeResidual);
  REGISTER_COMMAND(VMGCommandCheckResidual);
  REGISTER_COMMAND(VMGCommandClearCoarseLevels);
  REGISTER_COMMAND(VMGCommandClearGrid);
  REGISTER_COMMAND(VMGCommandCopyBoundary);
  REGISTER_COMMAND(VMGCommandExecuteCycle);
  REGISTER_COMMAND(VMGCommandExecuteCycleLoop);
  REGISTER_COMMAND(VMGCommandExecuteFullCycle);
  REGISTER_COMMAND(VMGCommandExecuteFullCycleLoop);
  REGISTER_COMMAND(VMGCommandExportSolution);
  REGISTER_COMMAND(VMGCommandForceDiscreteCompatibility);
  REGISTER_COMMAND(VMGCommandImportRightHandSide);
  REGISTER_COMMAND(VMGCommandInterpolateFMG);
  REGISTER_COMMAND(VMGCommandInitializeResidualNorm);
  REGISTER_COMMAND(VMGCommandPrintDefect);
  REGISTER_COMMAND(VMGCommandPrintGridStructure);
  REGISTER_COMMAND(VMGCommandPrintGrid);
  REGISTER_COMMAND(VMGCommandPrintInnerGrid);
  REGISTER_COMMAND(VMGCommandPrintResidualNorm);
  REGISTER_COMMAND(VMGCommandProlongate);
  REGISTER_COMMAND(VMGCommandRestrict);
  REGISTER_COMMAND(VMGCommandSetAverageToZero);
  REGISTER_COMMAND(VMGCommandSetCoarserDirichletValues);
  REGISTER_COMMAND(VMGCommandSetLevel);
  REGISTER_COMMAND(VMGCommandSmooth);
  REGISTER_COMMAND(VMGCommandSolve);
}

MG::MG()
{
  VMGRegisterBuiltinCommands();
}

MG::~MG()
{
  MG::Destroy();
}

// Brings Multigrid back to starting state.
void MG::Destroy()
{
  MG::factory.Destroy();
}

void MG::SetInterface(VMG::Interface* interface, VMG::Comm* comm)
{
  interface->Register("INTERFACE");

  Multigrid* sol = new Multigrid(comm, interface);
  Multigrid* rhs = new Multigrid(comm, interface);
  VMG::TempGrid* temp = new VMG::TempGrid();

  sol->Register("SOL");
  rhs->Register("RHS");
  temp->Register("TEMPGRID");

  new ObjectStorage<int>("GLOBAL_MAXLEVEL", sol->GlobalMaxLevel());
  new ObjectStorage<int>("MINLEVEL", sol->MinLevel());
  new ObjectStorage<int>("MAXLEVEL", sol->MaxLevel());
}

/**
 * Solves a given system with a multigrid method
 *
 */
void MG::Solve()
{
  CommandList* cl_init = factory.GetObject("COMMANDLIST_INIT")->Cast<CommandList>();
  CommandList* cl_loop = factory.GetObject("COMMANDLIST_LOOP")->Cast<CommandList>();
  CommandList* cl_finalize = factory.GetObject("COMMANDLIST_FINALIZE")->Cast<CommandList>();

  cl_init->ExecuteList();

  while (cl_loop->ExecuteList() == Continue);

  cl_finalize->ExecuteList();
}

Comm* MG::GetComm()
{
  return factory.GetObject("COMM")->Cast<VMG::Comm>();
}

Discretization* MG::GetDiscretization()
{
  return factory.GetObject("DISCRETIZATION")->Cast<VMG::Discretization>();
}

LevelOperator* MG::GetLevelOperator()
{
  return factory.GetObject("LEVEL_OPERATOR")->Cast<VMG::LevelOperator>();
}

Multigrid* MG::GetRhs()
{
  return factory.GetObject("RHS")->Cast<VMG::Multigrid>();
}

Multigrid* MG::GetSol()
{
  return factory.GetObject("SOL")->Cast<VMG::Multigrid>();
}

Smoother* MG::GetSmoother()
{
  return factory.GetObject("SMOOTHER")->Cast<VMG::Smoother>();
}

Solver* MG::GetSolver()
{
  return factory.GetObject("SOLVER")->Cast<VMG::Solver>();
}

TempGrid* MG::GetTempGrid()
{
  return factory.GetObject("TEMPGRID")->Cast<VMG::TempGrid>();
}

Factory& MG::GetFactory()
{
  return MG::factory;
}

Interface* MG::GetInterface()
{
  return factory.GetObject("INTERFACE")->Cast<VMG::Interface>();
}

static bool CheckObject(std::string id)
{
  Object *obj = MG::GetFactory().GetObject(id);

#ifdef DEBUG
  if (obj == NULL)
    printf("\nMultigrid: CLASS %s NOT INITIALIZED\n\n", id.c_str());
#endif

  return obj != NULL;
}

bool MG::IsInitialized()
{
  bool init = true;

  init &= CheckObject("COMM");
  init &= CheckObject("LEVEL_OPERATOR");
  init &= CheckObject("RHS");
  init &= CheckObject("SOL");
  init &= CheckObject("SOLVER");
  init &= CheckObject("SMOOTHER");
  init &= CheckObject("DISCRETIZATION");
  init &= CheckObject("MAX_ITERATION");
  init &= CheckObject("PRECISION");
  init &= CheckObject("PRESMOOTHSTEPS");
  init &= CheckObject("POSTSMOOTHSTEPS");
  init &= CheckObject("COMMANDLIST_INIT");
  init &= CheckObject("COMMANDLIST_LOOP");
  init &= CheckObject("COMMANDLIST_FINALIZE");
  init &= CheckObject("MINLEVEL");
  init &= CheckObject("MAXLEVEL");
  init &= CheckObject("GLOBAL_MAXLEVEL");
  init &= CheckObject("INTERFACE");

  return init;
}