/* -*- 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 <new_map_win.h>

 #include <nbtab.h>

 #include <mapstorage.h>

 bool NewMapWin::closeIfEscapeIsPressed(GdkEventKey* e)

 {

   if(e->keyval==GDK_Escape)

   {

     hide();

   }

   return true;

 }

 NewMapWin::NewMapWin(const std::string& title, NoteBookTab & mw, bool itisedge, bool edgenode):Gtk::Dialog(title, true, true),mytab(mw),node("Create NodeMap"),edge("Create EdgeMap")

 {

   set_default_size(200, 50);

   signal_key_press_event().connect(sigc::mem_fun(*this, &NewMapWin::closeIfEscapeIsPressed));

   Gtk::VBox * vbox=get_vbox();

   //entries

   table=new Gtk::Table(3, 2, false);

   label=new Gtk::Label;

   label->set_text("Name of new map:");

   name.set_text("");

   (*table).attach(*label,0,1,0,1,Gtk::SHRINK,Gtk::SHRINK,10,3);

   (*table).attach(name,1,2,0,1,Gtk::SHRINK,Gtk::SHRINK,10,3);

   label=new Gtk::Label;

   label->set_text("Default value in the map:");

   default_value.set_text("0");

   (*table).attach(*label,0,1,1,2,Gtk::SHRINK,Gtk::SHRINK,10,3);

   (*table).attach(default_value,1,2,1,2,Gtk::SHRINK,Gtk::SHRINK,10,3);

   //node vs. edge map selector

   Gtk::RadioButton::Group group = node.get_group();

   edge.set_group(group);

   if(edgenode)

     {

       (*table).attach(node,0,1,2,3,Gtk::SHRINK,Gtk::SHRINK,10,3);

       (*table).attach(edge,1,2,2,3,Gtk::SHRINK,Gtk::SHRINK,10,3);

     }

   else

     {

       if(itisedge)

 	{

 	  edge.set_active();

 	}

       else

 	{

 	  node.set_active();

 	}

     }

   vbox->pack_start(*table);

   //OK button

   add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

   show_all_children();

 }

 void NewMapWin::on_response(int response_id)

 {

   if(response_id==Gtk::RESPONSE_OK)

     {

       double def_val=0;

       //get and formulate text

       std::string def_val_str=default_value.get_text();

       bool only_nums=true;

       for(int i=0;i<(int)def_val_str.size() && only_nums;i++)

 	{

 	  if( def_val_str[i]<'0' || def_val_str[i]>'9' )

 	    {

 	      only_nums=false;

 	    }

 	}

       std::string polishform;

       if(only_nums)

 	{

 	  def_val=atof(def_val_str.c_str());

 	}

       else

 	{

 	  polishform=string2Polishform(def_val_str,edge.get_active());

 	}

       //get name of text

       std::string mapname=name.get_text();

       if(!mapname.empty()&&(!polishform.empty()||only_nums))

 	{

 	  int abortion=0;

 	  if(edge.get_active())

 	    {

 	      //create the new map

 	      Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> (mytab.mapstorage->graph, def_val);

 	      if(!only_nums)

 		{

 		  std::stack<double> polishstack;

 		  for(EdgeIt k(mytab.mapstorage->graph); k!=INVALID; ++k)

 		    {

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

 			{

 			  double op1=0, op2=0;

 			  bool operation=true;

 			  switch(polishform[i])

 			    {

 			    case '+':

 			    case '-':

 			    case '/':

 			    case '*':

 			      op1=polishstack.top();

 			      polishstack.pop();

 			      op2=polishstack.top();

 			      polishstack.pop();

 			      break;

 			    default:

 			      //substitute variable

 			      std::map< std::string,Graph::EdgeMap<double> * > ems=mytab.mapstorage->edgemap_storage;

 			      bool itisvar=(ems.find(ch2var[ polishform[i] ])!=ems.end());

 			      if(itisvar)

 				{

 				  polishstack.push( (*(mytab.mapstorage->edgemap_storage[ ch2var[ polishform[i] ] ]))[k]);

 				}

 			      else

 				{

 				  polishstack.push(atof(ch2var[ polishform[i] ].c_str()));

 				}

 			      operation=false;

 			      break;

 			    }

 			  if(operation)

 			    {

 			      double res;

 			      switch(polishform[i])

 				{

 				case '+':

 				  res=op1+op2;

 				  break;

 				case '-':

 				  res=op2-op1;

 				  break;

 				case '/':

 				  res=op2/op1;

 				  break;

 				case '*':

 				  res=op1*op2;

 				  break;

 				default:

 				  std::cout << "How could we get here?" << std::endl;

 				  break;

 				}

 			      polishstack.push(res);

 			    }

 			}//foreach letter in polishform

 		      (*emptr)[k]=polishstack.top(); 

 		    }//foreach edge

 		}//!only_nums

 	      //if addition was not successful addEdgeMap returns one.

 	      //cause can be that there is already a map named like the new one

 	      if(mytab.mapstorage->addEdgeMap(mapname, emptr, def_val))

 		{

 		  abortion=1;

 		}

 	      //add it to the list of the displayable maps

 	      //furthermore it is done by signals

 	      //mytab.registerNewEdgeMap(mapname);

 	      //display it

 	      //gdc.changeEdgeText(mapname);

 	    }

 	  else //!edge.get_active()

 	    {

 	      //create the new map

 	      Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> (mytab.mapstorage->graph, def_val);

 	      if(!only_nums)

 		{

 		  std::stack<double> polishstack;

 		  for(NodeIt k(mytab.mapstorage->graph); k!=INVALID; ++k)

 		    {

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

 			{

 			  double op1=0, op2=0;

 			  bool operation=true;

 			  switch(polishform[i])

 			    {

 			    case '+':

 			    case '-':

 			    case '/':

 			    case '*':

 			      op1=polishstack.top();

 			      polishstack.pop();

 			      op2=polishstack.top();

 			      polishstack.pop();

 			      break;

 			    default:

 			      std::map< std::string,Graph::NodeMap<double> * > nms=mytab.mapstorage->nodemap_storage;

 			      bool itisvar=(nms.find(ch2var[ polishform[i] ])!=nms.end());

 			      if(itisvar)

 				{

 				  polishstack.push( (*(mytab.mapstorage->nodemap_storage[ ch2var[ polishform[i] ] ]))[k]);

 				}

 			      else

 				{

 				  polishstack.push(atof(ch2var[ polishform[i] ].c_str()));

 				}

 			      operation=false;

 			      break;

 			    }

 			  if(operation)

 			    {

 			      double res;

 			      switch(polishform[i])

 				{

 				case '+':

 				  res=op1+op2;

 				  break;

 				case '-':

 				  res=op2-op1;

 				  break;

 				case '/':

 				  res=op2/op1;

 				  break;

 				case '*':

 				  res=op1*op2;

 				  break;

 				default:

 				  std::cout << "How could we get here?" << std::endl;

 				  break;

 				}

 			      polishstack.push(res);

 			    }

 			}

 		      (*emptr)[k]=polishstack.top(); 

 		    }

 		}

 	      //if addition was not successful addNodeMap returns one.

 	      //cause can be that there is already a map named like the new one

 	      if(mytab.mapstorage->addNodeMap(mapname,emptr, def_val))

 		{

 		  abortion=1;

 		}

 	      //add it to the list of the displayable maps

 	      //furthermore it is done by signals

 	      //mytab.registerNewNodeMap(mapname);

 	      //display it

 	      //gdc.changeNodeText(mapname);

 	    }

 	  if(!abortion)

 	    {

 	      name.set_text("");

 	      default_value.set_text("0");

 	      edge.show();

 	      node.show();

 	      hide();

 	    }

 	}

     }

 }

 std::string NewMapWin::string2Polishform(std::string rawcommand, bool itisedge)

 {

   bool valid_entry=true;

   std::map<std::string, int> str2i;

   std::string command;

   std::string variable;

   char index='a';

   for(int i=0;(valid_entry&&(i<(int)rawcommand.size()));i++)

     {

       switch(rawcommand[i])

 	{

 	case '+':

 	case '-':

 	case '*':

 	case '/':

 	case ')':

 	case '(':

  	  if(!variable.empty())

 	    {

 	      valid_entry=validVariable(variable, itisedge);

 	      ch2var[index]=variable;

 	      command+=index;

 	      index++;

 	      variable.erase(0,variable.size());	  

 	    }

 	  command+=rawcommand[i];

 	  break;

 	default:

 	  variable+=rawcommand[i];

 	  break;

 	}

     }

   if(!variable.empty()&&valid_entry)

     {

       valid_entry=validVariable(variable, itisedge);

       ch2var[index]=variable;

       command+=index;

       index++;

       variable.erase(0,variable.size());	  

     }

   if(valid_entry)

     {

       unsigned int pr=10000;

       bool prevmult=false;

       unsigned int prev_change=pr;

       unsigned int prev_br=pr;

       int counter=0;

       std::string comm_nobr="";

       std::vector<unsigned int> p;

       p.resize(counter+1);

       //limits

       //6 brackets embedded

       //100 operation in a row from the same priority

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

 	{

 	  bool put_in_string=true;

 	  switch(command[i])

 	    {

 	    case '(':

 	      pr=prev_br+10000;

 	      prev_br=pr;

 	      prevmult=false;

 	      put_in_string=false;

 	      break;

 	    case ')':

 	      pr=prev_br-10000;

 	      prev_br=pr;

 	      prevmult=false;

 	      put_in_string=false;

 	      break;

 	    case '+':

 	    case '-':

 	      if(prevmult)

 		{

 		  pr=prev_change;

 		}

 	      p[counter]=pr;

 	      pr-=100;

 	      prevmult=false;

 	      break;

 	    case '/':

 	    case '*':

 	      if(!prevmult)

 		{

 		  prev_change=pr;

 		  pr+=200;

 		  pr-=1;

 		}

 	      p[counter]=pr;

 	      pr-=1;

 	      prevmult=true;

 	      break;

 	    default:

 	      p[counter]=65000;

 	      break;

 	    }

 	  if(put_in_string)

 	    {

 	      counter++;

 	      p.resize(counter+1);

 	      comm_nobr=comm_nobr+command[i];

 	    }

 	}

       tree_node * root=weightedString2Tree(comm_nobr, p, 0);

       std::string polishform=postOrder(root);

       deleteTree(root);

       return polishform;

     }

   return "";

 }

 void NewMapWin::deleteTree(NewMapWin::tree_node * node)

 {

   if(node->left_child!=NULL)

     {

       deleteTree(node->left_child);

     }

   if(node->right_child!=NULL)

     {

       deleteTree(node->right_child);

     }

   delete node;

 }

 NewMapWin::tree_node * NewMapWin::weightedString2Tree(std::string to_tree, std::vector<unsigned int> & p, int offset)

 {

   unsigned int min=p[offset];

   int minplace=0;

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

     {

       if(min>p[offset+i])

 	{

 	  min=p[offset+i];

 	  minplace=i;

 	}

     }

   tree_node * act_node=new tree_node;

   act_node->ch=to_tree[minplace];

   if(to_tree.size()>=3)

     {

       act_node->left_child=weightedString2Tree(to_tree.substr(0,minplace), p, offset);

       act_node->right_child=weightedString2Tree(to_tree.substr(minplace+1,to_tree.size()-minplace-1), p, offset+minplace+1);

     }

   else

     {

       act_node->left_child=NULL;

       act_node->right_child=NULL;

     }

   return act_node;

 }

 std::string NewMapWin::postOrder(tree_node * subtree)

 {

   std::string subtree_to_string;

   if(subtree->left_child)

     {

       subtree_to_string=postOrder(subtree->left_child);

     }

   if(subtree->right_child)

     {

       subtree_to_string=subtree_to_string+postOrder(subtree->right_child);

     }

   subtree_to_string=subtree_to_string+subtree->ch;

   return subtree_to_string;

 }

 bool NewMapWin::validVariable(std::string variable, bool itisedge)

 {

   bool cancel;

   //is it mapname?

   if(itisedge)

     {

       cancel=(mytab.mapstorage->edgemap_storage.find(variable)==mytab.mapstorage->edgemap_storage.end());

     }

   else

     {

       cancel=(mytab.mapstorage->nodemap_storage.find(variable)==mytab.mapstorage->nodemap_storage.end());

     }

   //maybe it is number

   int point_num=0;

   if(cancel)

     {

       cancel=false;

       for(int j=0;(!cancel)&&(j<(int)variable.size());j++)

 	{

 	  if(((variable[j]<'0')||(variable[j]>'9'))&&(variable[j]!='.'))

 	    {

 	      cancel=true;

 	    }

 	  else

 	    {

 	      if(variable[j]=='.')

 		{

 		  point_num++;

 		  if(point_num>1)

 		    {

 		      cancel=true;

 		    }

 		}

 	    }

 	}

     }

   if(cancel)

     {

       return false;

     }

   return true;

 }