/* -*- C++ -*-

  * src/lemon/graph_reader.h - Part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Combinatorial Optimization Research Group, 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.

  *

  */

 ///\ingroup gio

 ///\file

 ///\brief Map utilities.

 #include <iostream>

 #include <sstream>

 #include <map>

 #include <vector>

 #include <lemon/error.h>

 /// \todo fix exceptions

 namespace lemon {

   struct DefaultReaderTraits {

     template <typename _Value>

     struct Reader {

       typedef _Value Value;

       void read(std::istream& is, Value& value) {

 	is >> value;

       }

     };

     template <typename _Value>

     struct Skipper {

       typedef _Value Value;

       void read(std::istream& is) {

 	Value tmp;

 	is >> tmp;

       }      

     };

     struct DefaultSkipper {

       void read(std::istream& is) {

 	std::string tmp;

 	is >> tmp;

       }

     };

   };

   class IOException {

     virtual string message() = 0;

   };

   class FileReaderException {

     virtual int getLine() = 0;    

   };

   template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits> 

   class GraphReader {

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef typename Graph::Edge Edge;

     typedef _ReaderTraits ReaderTraits;

     GraphReader(std::istream& _is, Graph& _graph) : is(_is), graph(_graph) {}

     template <typename Map>

     GraphReader& readNodeMap(std::string name, Map& map, 

 			     const typename ReaderTraits::template Reader<typename Map::Value>& reader =

 			     typename ReaderTraits::template Reader<typename Map::Value>()) {

       return readNodeMap<Map, typename ReaderTraits::template Reader<typename Map::Value> >(name, map, reader);

     }

     template <typename Map, typename Reader>

     GraphReader& readNodeMap(std::string name, Map& map, const Reader& reader = Reader()) {

       node_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));

       return *this;

     }

     template <typename Map>

     GraphReader& readEdgeMap(std::string name, Map& map, 

 			     const typename ReaderTraits::template Reader<typename Map::Value>& reader =

 			     typename ReaderTraits::template Reader<typename Map::Value>()) {

       return readEdgeMap<Map, typename ReaderTraits::template Reader<typename Map::Value> >(name, map, reader);

     }

     template <typename Map, typename Reader>

     GraphReader& readEdgeMap(std::string name, Map& map, const Reader& reader = Reader()) {

       edge_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));

       return *this;

     }

     void read() {

       int line_num = 0;

       readNodeSet(line_num);

       readEdgeSet(line_num);

       {

 	std::string line = readNotEmptyLine(is, line_num);

       }

     }

   private:

     void readNodeSet(int& line_num) {

       int n = 0;

       {

 	std::string line = readNotEmptyLine(is, line_num);	

       }

       std::vector<MapReaderBase<Node>*> index;

       {

 	std::string line = readNotEmptyLine(is, line_num);    

 	std::string id;

 	std::istringstream ls(line);	

 	while (ls >> id) {

 	  typename map<std::string, MapReaderBase<Node>* >::iterator it = node_readers.find(id);

 	  if (it != node_readers.end()) {

 	    index.push_back(it->second);

 	  } else {

 	    index.push_back(0);

 	  }

 	  ++n;

 	}

       }

       std::string line;

       while (line = readNotEmptyLine(is, line_num), line[0] != '@') {

 	Node node = graph.addNode();

 	std::istringstream ls(line);

 	for (int i = 0; i < n; ++i) {

 	  if (index[i] != 0) {	    

 	    index[i]->read(ls, node);

 	  } else {

 	    default_skipper.read(ls);

 	  }

 	}

       }

     }

     void readEdgeSet(int& line_num) {

     }

     std::string readNotEmptyLine(std::istream& is, int& line_num) {

       std::string line;

       while (++line_num, getline(is, line)) {	

 	int vi = line.find_first_not_of(" \t");

 	if (vi != string::npos && line[vi] != '#') {

 	  return line.substr(vi);

 	}

       }

       throw Exception();

     }

     istream& is;

     Graph& graph;

     typename ReaderTraits::DefaultSkipper default_skipper;

     template <typename _Item>    

     class MapReaderBase {

     public:

       typedef _Item Item;

       virtual void read(istream& is, const Item& item) = 0;

     };

     template <typename _Item, typename _Map, typename _Reader>

     class MapReader : public MapReaderBase<_Item> {

     public:

       typedef _Map Map;

       typedef _Reader Reader;

       typedef _Item Item;

       Map& map;

       Reader reader;

       MapReader(Map& _map, const Reader& _reader) 

 	: map(_map), reader(_reader) {}

       virtual void read(istream& is, const Item& item) {

 	typename Reader::Value value;

 	reader.read(is, value);

 	map.set(item, value);

       }

     };

     typedef std::map<std::string, MapReaderBase<Node>* > NodeReaders;

     NodeReaders node_readers;

     typedef std::map<std::string, MapReaderBase<Edge>* > EdgeReaders;

     EdgeReaders edge_readers;

   };

 }