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

 *

 */

#ifndef MAPSTORAGE_H

#define MAPSTORAGE_H

class Mapstorage;

#include <vector>

#include <map>

#include <string>

#include "all_include.h"

#include "xymap.h"

#include <libgnomecanvasmm.h>

#include "map_value.h"

#include "map_value_map.h"

///class MapStorage handles NodeMaps and EdgeMaps.

///Class MapStorage is responsible for storing

///NodeMaps and EdgeMaps that can be shown later

///on GUI. Therefore maps can be added to it,

///and datas over the added maps can be queried.

///The maps will be stored in an std::map,

///referenced with their names. Unfortunately at

///the moment it works only with double type maps

///

///\todo too many things are public!!

class MapStorage

{

private:

  std::string background_file_name;

  bool background_set;

  double background_scaling;

public:

  class Error : public std::exception

  {

    private:

      std::string message;

    public:

      Error(const std::string& msg) : message(msg) {}

      virtual const char* what() const throw()

      {

        return message.c_str();

      }

      ~Error() throw() {}

  };

  void setBackground(const std::string& file_name);

  const std::string& getBackgroundFilename();

  bool isBackgroundSet();

  double getBackgroundScaling();

  void setBackgroundScaling(double scaling);

  enum MapSaveDest { GUI_SECT, NESET_SECT, DONT_SAVE };

  enum GuiSectSaveDest { LGF_FILE, CONF_FILE };

  struct SpecMapSaveOpts

  {

    enum Dest { GUI_SECT, NESET_SECT };

    enum MapNum { ONE_MAP, TWO_MAPS };

  };

  typedef Graph::NodeMap<double> NumericNodeMap;

  typedef Graph::NodeMap<std::string> StringNodeMap;

  typedef Graph::EdgeMap<double> NumericEdgeMap;

  typedef Graph::EdgeMap<std::string> StringEdgeMap;

  typedef Graph::NodeMap<int> NodeLabelMap;

  typedef Graph::EdgeMap<int> EdgeLabelMap;

  typedef XYMap<Graph::NodeMap<double> > NodeCoordMap;

  typedef XYMap<Graph::EdgeMap<double> > ArrowCoordMap;

  struct EdgeMapData

  {

    /// where to save the map

    MapSaveDest save_dest;

    /// read-only or read-write

    bool writeable;

    /// default value

    MapValue default_value;

    virtual MapValue::Type type() = 0;

    virtual MapValue get(Edge e) = 0;

    virtual void set(Edge e, MapValue v) = 0;

    EdgeMapData(MapValue def_val) :

      save_dest(GUI_SECT),

      writeable(true),

      default_value(def_val)

    {}

  };

  struct NumericEdgeMapData : public EdgeMapData

  {

    NumericEdgeMap map;

    MapValue::Type type() { return MapValue::NUMERIC; }

    MapValue get(Edge e) { return MapValue(map[e]); }

    void set(Edge e, MapValue v) { map.set(e, static_cast<double>(v)); }

    NumericEdgeMapData(Graph& g, double def_val) :

      EdgeMapData(MapValue(def_val)),

      map(g, def_val)

    {}

  };

  struct StringEdgeMapData : public EdgeMapData

  {

    StringEdgeMap map;

    MapValue::Type type() { return MapValue::STRING; }

    MapValue get(Edge e) { return MapValue(map[e]); }

    void set(Edge e, MapValue v) { map.set(e, static_cast<std::string>(v)); }

    StringEdgeMapData(Graph& g, std::string def_val) :

      EdgeMapData(MapValue(def_val)),

      map(g, def_val)

    {}

  };

  struct NodeMapData

  {

    /// where to save the map

    MapSaveDest save_dest;

    /// read-only or read-write

    bool writeable;

    /// default value

    MapValue default_value;

    virtual MapValue::Type type() = 0;

    virtual MapValue get(Node e) = 0;

    virtual void set(Node e, MapValue v) = 0;

    NodeMapData(MapValue def_val) :

      save_dest(GUI_SECT),

      writeable(true),

      default_value(def_val)

    {}

  };

  struct NumericNodeMapData : public NodeMapData

  {

    NumericNodeMap map;

    MapValue::Type type() { return MapValue::NUMERIC; }

    MapValue get(Node e) { return MapValue(map[e]); }

    void set(Node e, MapValue v) { map.set(e, static_cast<double>(v)); }

    NumericNodeMapData(Graph& g, double def_val) :

      NodeMapData(MapValue(def_val)),

      map(g, def_val)

    {}

  };

  struct StringNodeMapData : public NodeMapData

  {

    StringNodeMap map;

    MapValue::Type type() { return MapValue::STRING; }

    MapValue get(Node e) { return MapValue(map[e]); }

    void set(Node e, MapValue v) { map.set(e, static_cast<std::string>(v)); }

    StringNodeMapData(Graph& g, std::string def_val) :

      NodeMapData(MapValue(def_val)),

      map(g, def_val)

    {}

  };

  typedef std::map<std::string, NodeMapData*> NodeMapStore;

  typedef std::map<std::string, EdgeMapData*> EdgeMapStore;

  struct GUISectData

  {

    std::vector<std::string> main_node_map_names;

    std::vector<std::string> main_edge_map_names;

    std::vector<std::string> gui_node_map_names;

    std::vector<std::string> gui_edge_map_names;

    std::map<std::string, MapValue::Type> node_map_types;

    std::map<std::string, MapValue::Type> edge_map_types;

    std::map<std::string, std::map<int, double>* > numeric_node_maps;

    std::map<std::string, std::map<int, std::string>* > string_node_maps;

    std::map<std::string, std::map<int, double>* > numeric_edge_maps;

    std::map<std::string, std::map<int, std::string>* > string_edge_maps;

    std::map<int, XY> node_coord_map;

    std::map<int, XY> arrow_coord_map;

    SpecMapSaveOpts::Dest node_coords_save_dest;

    SpecMapSaveOpts::MapNum node_coords_save_map_num;

    std::string node_coords_one_map_name;

    std::string node_coords_two_maps_1_name;

    std::string node_coords_two_maps_2_name;

    SpecMapSaveOpts::Dest arrow_coords_save_dest;

    SpecMapSaveOpts::MapNum arrow_coords_save_map_num;

    std::string arrow_coords_one_map_name;

    std::string arrow_coords_two_maps_1_name;

    std::string arrow_coords_two_maps_2_name;

    ~GUISectData()

    {

      using std::map;

      using std::vector;

      using std::pair;

      using std::string;

      for (map<string, map<int, double>* >::iterator it =

          numeric_node_maps.begin(); it != numeric_node_maps.end(); ++it)

      {

        delete it->second;

      }

      for (map<string, map<int, string>* >::iterator it =

          string_node_maps.begin(); it != string_node_maps.end(); ++it)

      {

        delete it->second;

      }

      for (map<string, map<int, double>* >::iterator it =

          numeric_edge_maps.begin(); it != numeric_edge_maps.end(); ++it)

      {

        delete it->second;

      }

      for (map<string, map<int, string>* >::iterator it =

          string_edge_maps.begin(); it != string_edge_maps.end(); ++it)

      {

        delete it->second;

      }

    }

  };

public:

  ///The graph for which the datas are stored.

  Graph graph;

  const Graph& getGraph();

private:

  GuiSectSaveDest gui_sect_save_dest;

  SpecMapSaveOpts::Dest node_coords_save_dest;

  SpecMapSaveOpts::MapNum node_coords_save_map_num;

  SpecMapSaveOpts::Dest arrow_coords_save_dest;

  SpecMapSaveOpts::MapNum arrow_coords_save_map_num;

  NodeMapStore nodemaps;

  EdgeMapStore edgemaps;

  NodeLabelMap node_label;

  EdgeLabelMap edge_label;

  /// the coordinates of the nodes

  NodeCoordMap node_coords;

  Graph::NodeMap<double> node_coords_x;

  Graph::NodeMap<double> node_coords_y;

  /// the coordinates of the arrows on the edges

  ArrowCoordMap arrow_coords;

  Graph::EdgeMap<double> arrow_coords_x;

  Graph::EdgeMap<double> arrow_coords_y;

  ///The content of the object has changed, update is needed.

  bool modified;

  ///Name of file loaded in object.

  std::string file_name;

  // the largest node label

  int max_node_label;

  // the largest edge label

  int max_edge_label;

  std::string node_coords_one_map_name;

  std::string node_coords_two_maps_1_name;

  std::string node_coords_two_maps_2_name;

  std::string arrow_coords_one_map_name;

  std::string arrow_coords_two_maps_1_name;

  std::string arrow_coords_two_maps_2_name;

public:

  ///Stores the default values for the different visualization node attributes

  std::vector<Graph::NodeMap<double> > default_nodemaps;

  ///Stores the default values for the different visualization edge attributes

  std::vector<Graph::EdgeMap<double> > default_edgemaps;

  ///Stores the active maps for the different visualization node attributes

  std::vector< std::string > active_nodemaps;

  /// Stores the active maps for the different visualization edge attributes

  std::vector< std::string > active_edgemaps;

protected:

  /// Signal emitted on any change made on map values

  /// Signal emitted if the visualization of the maps might have to be updated.

  /// bool shows us whether the changed map is edge or nodemap.

  /// int tells us the refreshed property

  sigc::signal<void, bool, int> signal_prop;

  /// Signal emitted in the case of nodemap addition

  /// std::string is the

  ///name of the new map

  sigc::signal<void, std::string, MapValue::Type> signal_node_map;

  /// Signal emitted in the case of edgemap addition

  /// std::string is the

  ///name of the new map

  sigc::signal<void, std::string, MapValue::Type> signal_edge_map;

  /// Signal emitted, when entry in \ref MapWin should be changed.

  sigc::signal<void, bool, int, std::string> signal_map_win;

  /// Signal emitted, when entry in \ref DesignWin should be changed.

  sigc::signal<void, double, double, int> signal_design_win;

  ///Signal emitted when background should be set by \ref NoteBookTab

  sigc::signal<void> signal_background;

  ///Iteration number during graph design

  int iterations;

  ///Attraction factor during graph design

  double attraction;

  ///Propulsation factor during graph design

  double propulsation;

public:

  ///Constructor of MapStorage.

  ///Its all activity is initializing default values

  ///for different visualization attributes.

  MapStorage();

  ///Destructor of MapStorage

  ///Maps stored here are created with new. Destructor

  ///deletes them to free up the reserved memory.

  ~MapStorage();

  /// Registrates if the shown map by any attribute has changed to another.

  ///It handles the \ref active_edgemaps and

  ///\ref active_nodemaps vectors. It also emits \ref signal_prop signal to let

  ///know the interested objects that the visible map of a certain

  ///attribute has changed.

  ///\param itisedge edgemap or nodemap has changed

  ///\param prop the property of which the map is changed

  ///\param mapname the visible map

  void changeActiveMap(bool itisedge , int prop , std::string mapname);

  ///Emits signals that let change the active maps in \ref MapWin.

  void broadcastActiveMaps();

  /// Returns the active edgemap shown by a visualization property.

  /// \param prop is the property

  ///that shows the requested map.

  std::string getActiveEdgeMap(int prop);

  /// Returns the active nodemap shown by a visualization property.

  /// \param prop is the property

  ///that shows the requested map.

  std::string getActiveNodeMap(int prop);

  /// Returns the names of the edgemaps stored here.

  std::vector<std::string> getEdgeMapList(MapType type = ALL);

  /// Returns the names of the nodemaps stored here.

  std::vector<std::string> getNodeMapList(MapType type = ALL);

  ///returns \ref signal_prop to be able to connect functions to it

  sigc::signal<void, bool, int> signal_prop_ch();

  ///returns \ref signal_node_map to be able to connect functions to it

  sigc::signal<void, std::string, MapValue::Type> signal_node_map_ch(){return signal_node_map;};

  ///returns \ref signal_edge_map to be able to connect functions to it

  sigc::signal<void, std::string, MapValue::Type> signal_edge_map_ch(){return signal_edge_map;};

  ///returns \ref signal_map_win to be able to connect functions to it

  sigc::signal<void, bool, int, std::string> signal_map_win_ch(){return signal_map_win;};

  ///returns \ref signal_design_win to be able to connect functions to it

  sigc::signal<void, double, double, int> signal_design_win_ch(){return signal_design_win;};

  void createNodeMap(const std::string& name, MapValue::Type type,

    MapValue def_val);

  void createEdgeMap(const std::string& name, MapValue::Type type,

    MapValue def_val);

  ///returns \ref signal_background to be able to connect functions to it

  sigc::signal<void> signal_background_ch(){return signal_background;};

  ///Adds given map to storage.

  ///Emits \ref signal_prop if mapvalues have changed, and MapStorage gets to know it.

  ///If values in a map have changed, this function checks, whether it is displayed.

  ///This check means searching the given mapname between active maps

  ///(\ref active_nodemaps, \ref active_edgemaps). If it is there at a certain property,

  ///it emits a signal with the property, where the gotten mapname was found. One signal

  ///is emitted for each property displaying the given map.

  ///\param itisedge whether the map an edgemap or nodemap

  ///\param mapname name of map to visualize

  void mapChanged(bool itisedge, std::string mapname);

  ///Read datas from the given filename.

  int readFromFile(const std::string &);

  ///Save datas to the given filename.

  void writeToFile(const std::string &);

  ///Deletes all datastructures stored here.

  void clear();

  void get_design_data(double &, double &, int &);

  void set_attraction(double);

  void set_propulsation(double);

  void set_iteration(int);

  void redesign_data_changed();

  XY getNodeCoords(Node n) const;

  void setNodeCoords(Node n, XY c);

  XY getArrowCoords(Edge e) const;

  void setArrowCoords(Edge e, XY c);

  MapValue get(const std::string& name, Node node) const;

  void set(const std::string& name, Node node, MapValue val);

  MapValue get(const std::string& name, Edge edge) const;

  void set(const std::string& name, Edge edge, MapValue val);

  const std::string& getFileName() const;

  void setFileName(const std::string& fn);

  bool getModified() const;

  void setModified(bool m = true);

  Node addNode(XY);

  Edge addEdge(Node, Node);

  NumericNodeMap& getNumericNodeMap(const std::string& name);

  StringNodeMap& getStringNodeMap(const std::string& name);

  NumericEdgeMap& getNumericEdgeMap(const std::string& name);

  StringEdgeMap& getStringEdgeMap(const std::string& name);

  MapValueEdgeMap getEdgeMap(const std::string& name);

  MapValueNodeMap getNodeMap(const std::string& name);

  int getLabel(Node) const;

  int getLabel(Edge) const;

  GuiSectSaveDest getGUIDataSaveLocation();

  void setGUIDataSaveLocation(GuiSectSaveDest dest);

  MapSaveDest getNodeMapSaveDest(std::string name) const;

  MapSaveDest getEdgeMapSaveDest(std::string name) const;

  void setNodeMapSaveDest(std::string name, MapSaveDest dest);

  void setEdgeMapSaveDest(std::string name, MapSaveDest dest);

  SpecMapSaveOpts::Dest getNodeCoordsSaveDest();

  SpecMapSaveOpts::Dest getArrowCoordsSaveDest();

  void setNodeCoordsSaveDest(SpecMapSaveOpts::Dest dest);

  void setArrowCoordsSaveDest(SpecMapSaveOpts::Dest dest);

  SpecMapSaveOpts::MapNum getNodeCoordsSaveMapNum();

  SpecMapSaveOpts::MapNum getArrowCoordsSaveMapNum();

  void setNodeCoordsSaveMapNum(SpecMapSaveOpts::MapNum num);

  void setArrowCoordsSaveMapNum(SpecMapSaveOpts::MapNum num);

  MapValue::Type getNodeMapElementType(std::string name) const;

  MapValue::Type getEdgeMapElementType(std::string name) const;

  const NodeLabelMap& getNodeLabelMap();

  const EdgeLabelMap& getEdgeLabelMap();

  bool nodeMapExists(std::string name);

  bool edgeMapExists(std::string name);

  std::vector<std::string> getEdgeMaps(MapType type = ALL);

  std::vector<std::string> getNodeMaps(MapType type = ALL);

  NodeCoordMap& getNodeCoordMap();

  ArrowCoordMap& getArrowCoordMap();

  const std::string& getNodeCoordsOneMapName();

  const std::string& getNodeCoordsTwoMaps1Name();

  const std::string& getNodeCoordsTwoMaps2Name();

  void setNodeCoordsOneMapName(const std::string& name);

  void setNodeCoordsTwoMaps1Name(const std::string& name);

  void setNodeCoordsTwoMaps2Name(const std::string& name);

  const std::string& getArrowCoordsOneMapName();

  const std::string& getArrowCoordsTwoMaps1Name();

  const std::string& getArrowCoordsTwoMaps2Name();

  void setArrowCoordsOneMapName(const std::string& name);

  void setArrowCoordsTwoMaps1Name(const std::string& name);

  void setArrowCoordsTwoMaps2Name(const std::string& name);

private:

  EdgeMapData* getEdgeMapData(std::string name) const;

  NodeMapData* getNodeMapData(std::string name) const;

  void readLGF(

      const std::string& filename,

      bool read_edge_label,

      const std::vector<std::string>& node_map_names,

      const std::vector<std::string>& edge_map_names,

      const std::map<std::string, MapValue::Type>& node_map_types,

      const std::map<std::string, MapValue::Type>& edge_map_types,

      const std::string& node_coord_xmap_name,

      const std::string& node_coord_ymap_name,

      const std::string& arrow_coord_xmap_name,

      const std::string& arrow_coord_ymap_name);

public:

  void exportGraphToEPS(std::vector<bool>, std::string, std::string);

};

#endif //MAPSTORAGE_H