/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2006

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#include <algobox.h>

#include <mapstorage.h>

#include <mapselector.h>

enum {N_DEMO1, N_DEMO2, NODE_INPUT_NUM}; // input IDs for nodes;

enum {E_DEMO1, EDGE_INPUT_NUM}; // input IDs for edges;

AlgoBox::AlgoBox(std::vector<std::string> tabnames)

{

  init(tabnames);

}

void AlgoBox::init(std::vector<std::string> tabnames)

{

  set_spacing(5);

  update_tablist(tabnames);

  //if active tab is changed, the map names in cbt/s have to be updated

  tabcbt.signal_changed().connect(sigc::mem_fun(*this, &AlgoBox::emit_tab_change));

  pack_start(tabcbt);

  build_box();

  show_all_children();

};

void AlgoBox::update_cbt(std::vector< std::string > stringlist, Gtk::ComboBoxText & cbt)

{

  std::string actname=cbt.get_active_text();

  int prev_act=-1;

  cbt.clear();

  int actptr=0;

  std::vector< std::string >::iterator emsi=stringlist.begin();

  for(;emsi!=stringlist.end();emsi++)

    {

      if(actname==*emsi)

	{

	  prev_act=actptr;

	}

      cbt.append_text(*emsi);

      actptr++;

    }

  if(prev_act!=-1)

    {

      cbt.set_active(prev_act);

    }

  else if(actptr>0) //so there is item in the list

    {

      //cbt.set_active(0);

    }

}

void AlgoBox::update_tablist( std::vector< std::string > tl )

{

  update_cbt(tl, tabcbt);

  emit_tab_change();

}

void AlgoBox::update_maplist(MapStorage * ms)

{

  mapstorage=ms;

  std::vector<std::string> n_nml;

  std::vector<std::string> s_nml;

  std::vector<std::string> n_eml;

  std::vector<std::string> s_eml;

  if(mapstorage!=NULL)

    {

      mapstorage->signal_node_map_ch().connect(sigc::mem_fun(*this, &AlgoBox::nodemaplist_changed));

      mapstorage->signal_edge_map_ch().connect(sigc::mem_fun(*this, &AlgoBox::edgemaplist_changed));

      n_nml=mapstorage->getNodeMapList(NUM);

      s_nml=mapstorage->getNodeMapList(STR);

      n_eml=mapstorage->getEdgeMapList(NUM);

      s_eml=mapstorage->getEdgeMapList(STR);

    }

  for(int i=0;i<(int)nodemapcbts.size();i++)

    {

      (nodemapcbts[i])->update_list(n_nml, s_nml);

      //update_cbt(nml, *(nodemapcbts[i]));

    }

  for(int i=0;i<(int)edgemapcbts.size();i++)

    {

      (edgemapcbts[i])->update_list(n_eml, s_eml);

      //update_cbt(eml, *(edgemapcbts[i]));

    }

  signal_maplist_updated.emit();

}

void AlgoBox::nodemaplist_changed(std::string newmap, MapValue::Type type)

{

  for(int i=0;i<(int)nodemapcbts.size();i++)

    {

      (nodemapcbts[i])->append_text(newmap, type);

    }

}

void AlgoBox::edgemaplist_changed(std::string newmap, MapValue::Type type)

{

  for(int i=0;i<(int)edgemapcbts.size();i++)

    {

      (edgemapcbts[i])->append_text(newmap, type);

    }

}

void AlgoBox::run()

{

  std::cout << "Start algorithm." << std::endl;

}

void AlgoBox::build_box()

{

  pack_start(*(new Gtk::HSeparator()));

  Gtk::Label * label=new Gtk::Label("Specific part for each algorithm.");

  pack_start(*label);

  pack_start(*(new Gtk::HSeparator()));

  label=new Gtk::Label("Maps in chosen tab:");

  pack_start(*label);

  for(int i=0;i<NODE_INPUT_NUM;i++)

    {

      std::ostringstream o;

      o << "NodeInput " << i+1 << ":";

      addMapSelector(o.str(), false);

    }

  pack_start(*(new Gtk::HSeparator()));

  for(int i=0;i<EDGE_INPUT_NUM;i++)

    {

      std::ostringstream o;

      o << "EdgeInput " << i+1 << ":";

      addMapSelector(o.str(), true);

    }

  pack_start(*(new Gtk::HSeparator()));

}

void AlgoBox::addMapSelector(std::string inputname, bool itisedge, MapType type)

{

  std::vector<std::string> empty_vector;

  MapSelector * msp=new MapSelector(empty_vector,empty_vector,"",inputname,itisedge, false, type);

  if(itisedge)

    {

      edgemapcbts.resize(edgemapcbts.size()+1);

      edgemapcbts[edgemapcbts.size()-1]=msp;

    }

  else

    {

      nodemapcbts.resize(nodemapcbts.size()+1);

      nodemapcbts[nodemapcbts.size()-1]=msp;

    }

  msp->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &AlgoBox::emit_new_map_signal));

  pack_start(*msp);

}

sigc::signal<void, std::string> AlgoBox::signal_maplist_needed()

{

  return signal_maplist_need;

}

void AlgoBox::emit_tab_change()

{

  std::string active_tab=tabcbt.get_active_text();

  if(active_tab!="")

    {

      signal_maplist_need.emit(active_tab);

    }

  else

    {

      std::vector<std::string> empty_vector;

      update_maplist(NULL);

    }

}

void AlgoBox::emit_new_map_signal(bool itisedge)

{

  signal_newmapwin_need.emit(tabcbt.get_active_text(), itisedge);

}