/**
 * @file   factory.cpp
 * @author Julian Iseringhausen <isering@ins.uni-bonn.de>
 * @date   Tue Apr  5 20:40:05 2011
 */

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

#include <cassert>
#include <cstdio>
#include <iostream>

#include "base/command.hpp"
#include "base/discretization.hpp"
#include "base/factory.hpp"
#include "base/object.hpp"
#include "comm/comm.hpp"
#include "grid/multigrid.hpp"
#include "grid/tempgrid.hpp"
#include "level/level_operator.hpp"
#include "smoother/smoother.hpp"
#include "solver/solver.hpp"
#include "mg.hpp"

using namespace VMG;

Factory::Factory()
{
}

Factory::~Factory()
{
  Destroy();

  for (Factory::command_iterator iter=command_map.begin(); iter!=command_map.end(); ++iter)
    delete iter->second;

  command_map.clear();
}

void Factory::Destroy()
{
  for (Factory::instance_iterator iter=command_instance_map.begin(); iter!=command_instance_map.end(); ++iter)
    delete iter->second;

  for (Factory::object_iterator iter=object_map.begin(); iter!=object_map.end(); ++iter)
    delete iter->second;

  command_instance_map.clear();
  object_map.clear();
}

void Factory::RegisterCommand(CommandProxyBase* object)
{
  if (command_map.find(object->Name()) == command_map.end())
    command_map.insert(std::pair<std::string, CommandProxyBase*>(object->Name(), object));
  else
    assert(0 == "A command with the same unique name has already been registered.");
}

void Factory::RegisterObject(Object* object)
{
  Factory::object_iterator iter = object_map.find(object->Name());

  if (iter != object_map.end()) {
    delete iter->second;
    object_map.erase(iter);
  }

  object_map.insert(std::pair<std::string, Object*>(object->Name(), object));
}

Command* Factory::GetCommand(std::string id)
{
  MG::Instance();
#ifdef DEBUG
  //std::cout << id << std::endl;
#endif

  Factory::instance_iterator iter1 = command_instance_map.find(id);
  if (iter1 != command_instance_map.end())
    return iter1->second;

  Factory::command_iterator iter2 = command_map.find(id);
  if (iter2 != command_map.end()) {
    Command *command = iter2->second->CreateCommand();
    command_instance_map.insert(std::pair<std::string, Command*>(id, command));
    return command;
  }

  assert(0 == "This command is not registered.");

  return NULL;
}

bool Factory::CheckNumberOfArguments(std::string id, const int& num_arguments)
{
  Factory::command_iterator iter = command_map.find(id);

  assert(iter != command_map.end());
  assert(iter->second->Arguments() == num_arguments);

  return iter->second->Arguments() == num_arguments;
}

Object* Factory::GetObject(std::string id)
{
  MG::Instance();

  Factory::object_iterator iter = object_map.find(id);
  if (iter != object_map.end())
    return iter->second;

  assert(0 == "This object is not registered.");

  return NULL;
}

void Factory::DeleteCommand(std::string id)
{
  Factory::command_iterator iter1 = command_map.find(id);

  if (iter1 != command_map.end()) {
    delete iter1->second;
    command_map.erase(iter1);
  }

  Factory::instance_iterator iter2 = command_instance_map.find(id);

  if (iter2 != command_instance_map.end()) {
    delete iter2->second;
    command_instance_map.erase(iter2);
  }
}

void Factory::DeleteObject(std::string id)
{
  Factory::object_iterator iter = object_map.find(id);

  if (iter != object_map.end()) {
    delete iter->second;
    object_map.erase(iter);
  }
}

void Factory::PrintAvailableCommands()
{
  for (Factory::command_iterator iter=command_map.begin(); iter!=command_map.end(); ++iter)
    printf("%s\n", iter->second->Name());
}

void Factory::PrintAvailableObjects()
{
  for (Factory::object_iterator iter=object_map.begin(); iter!=object_map.end(); ++iter)
    printf("%s\n", iter->second->Name().c_str());
}