/* -*- C++ -*-

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

 *

 * Copyright (C) 2005 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.

 *

 */

///\ingroup io_group

///\file

///\brief Lemon Format reader.

#ifndef LEMON_LEMON_READER_H

#define LEMON_LEMON_READER_H

#include <iostream>

#include <fstream>

#include <string>

#include <vector>

#include <algorithm>

#include <map>

#include <memory>

#include <lemon/error.h>

#include "item_reader.h"

namespace lemon {

  /// \addtogroup io_group

  /// @{

  /// \brief Lemon Format reader class.

  /// 

  class LemonReader {

  private:

    class FilterStreamBuf : public std::streambuf {

    public:

      typedef std::streambuf Parent;

      typedef Parent::char_type char_type;

      FilterStreamBuf(std::istream& is, int& num) 

	: _is(is), _base(0), _eptr(0), 

	  _num(num), skip_state(after_endl) {}

    protected:

      enum skip_state_type {

	no_skip,

	after_comment,

	after_endl,

	empty_line

      };

      char_type small_buf[1];

      std::istream& _is;

      char_type* _base;

      char_type* _eptr;

      int& _num;

      skip_state_type skip_state;

      char_type* base() { return _base; }

      char_type* eptr() { return _eptr; }

      int blen() { return _eptr - _base; }

      void setb(char_type* buf, int len) {

	_base = buf;

	_eptr = buf + len;

      }

      virtual std::streambuf* setbuf(char *buf, int len) {

	if (base()) return 0;

	if (buf != 0 && len >= (int)sizeof(small_buf)) {

	  setb(buf, len);

	} else {

	  setb(small_buf, sizeof(small_buf));

	}

	setg(0, 0, 0);

	return this;

      }

      bool put_char(char c) {

	switch (skip_state) {

	case no_skip:

	  switch (c) {

	  case '\n': 

	    skip_state = after_endl;

	    return true;

	  case '#':

	    skip_state = after_comment;

	    return false;

	  default:

	    return true;

	  }

	case after_comment:

	  switch (c) {

	  case '\n': 

	    skip_state = after_endl;

	    return true;

	  default:

	    return false;

	  }        

	case after_endl:

	  switch (c) {

	  case '@':

	    return false;

	  case '\n': 

	    return false;

	  case '#':

	    skip_state = empty_line;

	    return false;

	  default:

	    if (!isspace(c)) {

	      skip_state = no_skip;

	      return true;

	    } else {

	      return false;

	    }

	  }

	  break;

	case empty_line:

	  switch (c) {

	  case '\n': 

	    skip_state = after_endl;

	    return false;

	  default:

	    return false;

	  }

	}

	return false;

      }

      virtual int underflow() {

	char c;

	if (_is.read(&c, 1)) {

	  _is.putback(c);

	  if (c == '@') {

	    return EOF;

	  }

	} else {

	  return EOF;

	}

	char_type *ptr;

	for (ptr = base(); ptr != eptr(); ++ptr) {

	  if (_is.read(&c, 1)) {

	    if (c == '\n') ++_num;

	    if (put_char(c)) {

	      *ptr = c;

	    } else {

	      if (skip_state == after_endl && c == '@') {

		_is.putback('@');

		break;

	      }

	      --ptr;

	    }

	  } else {

	    break;

	  }

	}

	setg(base(), base(), ptr);

	return *base();

      }

      virtual int sync() {

	return EOF;

      }

    };

  public:

    class SectionReader {

    public:

      /// \e

      virtual bool header(const std::string& line) = 0;

      /// \e

      virtual void read(std::istream& is) = 0;

    };

    /// \e

    LemonReader(std::istream& _is) 

      : is(&_is), own_is(false) {}

    LemonReader(const std::string& filename) 

      : is(0), own_is(true) {

      is = new std::ifstream(filename.c_str());

    }

    ~LemonReader() {

      if (own_is) {

	delete is;

      }

    }

  private:

    LemonReader(const LemonReader&);

    void operator=(const LemonReader&);

  public:

    /// \e

    void attach(SectionReader& reader) {

      readers.push_back(&reader);

    }

    /// \e

    void detach(SectionReader& reader) {

      std::vector<SectionReader*>::iterator it = 

	std::find(readers.begin(), readers.end(), &reader);

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

	readers.erase(it);

      }

    }

    /// \e

    void run() {

      int line_num = 0;

      std::string line;

      try {

	while ((++line_num, getline(*is, line)) && line.find("@end") != 0) {

	  SectionReaders::iterator it;

	  for (it = readers.begin(); it != readers.end(); ++it) {

	    if ((*it)->header(line)) {

	      char buf[2048];

	      FilterStreamBuf buffer(*is, line_num);

	      buffer.pubsetbuf(buf, sizeof(buf));

	      std::istream is(&buffer);

	      (*it)->read(is);

	      break;

	    }

	  }

	}

      } catch (DataFormatError& error) {

	error.line(line_num);

	throw error;

      }	

    }

  private:

    std::istream* is;

    bool own_is;

    typedef std::vector<SectionReader*> SectionReaders;

    SectionReaders readers;

  };

  /// \e

  class CommonSectionReaderBase : public LemonReader::SectionReader {

  protected:

    template <typename _Item>

    class ReaderBase;

    template <typename _Item>

    class InverterBase : public ReaderBase<_Item> {

    public:

      typedef _Item Item;

      virtual void read(std::istream&, const Item&) = 0;

      virtual Item read(std::istream&) const = 0;

      virtual InverterBase<_Item>* getInverter() {

	return this;

      }

    };

    template <typename _Item, typename _Map, typename _Reader>

    class MapReaderInverter : public InverterBase<_Item> {

    public:

      typedef _Item Item;

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef _Map Map;

      typedef std::map<Value, Item> Inverse;

      Map& map;

      Reader reader;

      Inverse inverse;

      MapReaderInverter(Map& _map, const Reader& _reader) 

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

      virtual ~MapReaderInverter() {}

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

	Value value;

	reader.read(is, value);

	map.set(item, value);

	typename Inverse::iterator it = inverse.find(value);

	if (it == inverse.end()) {

	  inverse.insert(std::make_pair(value, item));

	} else {

	  throw DataFormatError("Multiple ID occurence");

	}

      }

      virtual Item read(std::istream& is) const {

	Value value;

	reader.read(is, value);	

	typename Inverse::const_iterator it = inverse.find(value);

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

	  return it->second;

	} else {

	  throw DataFormatError("Invalid ID error");

	}

      }      

    };

    template <typename _Item, typename _Reader>

    class SkipReaderInverter : public InverterBase<_Item> {

    public:

      typedef _Item Item;

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef std::map<Value, Item> Inverse;

      Reader reader;

      SkipReaderInverter(const Reader& _reader) 

	: reader(_reader) {}

      virtual ~SkipReaderInverter() {}

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

	Value value;

	reader.read(is, value);

	typename Inverse::iterator it = inverse.find(value);

	if (it == inverse.end()) {

	  inverse.insert(std::make_pair(value, item));

	} else {

	  throw DataFormatError("Multiple ID occurence error");

	}

      }

      virtual Item read(std::istream& is) const {

	Value value;

	reader.read(is, value);	

	typename Inverse::const_iterator it = inverse.find(value);

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

	  return it->second;

	} else {

	  throw DataFormatError("Invalid ID error");

	}

      }

    private:

      Inverse inverse;

    };

    // Readers

    template <typename _Item>    

    class ReaderBase {

    public:

      typedef _Item Item;

      virtual ~ReaderBase() {}

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

      virtual InverterBase<_Item>* getInverter() = 0;

    };

    template <typename _Item, typename _Map, typename _Reader>

    class MapReader : public ReaderBase<_Item> {

    public:

      typedef _Map Map;

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef _Item Item;

      Map& map;

      Reader reader;

      MapReader(Map& _map, const Reader& _reader) 

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

      virtual ~MapReader() {}

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

	Value value;

	reader.read(is, value);

	map.set(item, value);

      }

      virtual InverterBase<_Item>* getInverter() {

	return new MapReaderInverter<Item, Map, Reader>(map, reader);

      }

    };

    template <typename _Item, typename _Reader>

    class SkipReader : public ReaderBase<_Item> {

    public:

      typedef _Reader Reader;

      typedef typename Reader::Value Value;

      typedef _Item Item;

      Reader reader;

      SkipReader(const Reader& _reader) : reader(_reader) {}

      virtual ~SkipReader() {}

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

	Value value;

	reader.read(is, value);

      }      

      virtual InverterBase<Item>* getInverter() {

	return new SkipReaderInverter<Item, Reader>(reader);

      }

    };

    template <typename _Item>

    class ResolverReaderBase {

    public:

      typedef _Item Item;

      virtual Item resolve(std::istream& is) const = 0;

    };

    template <typename _Item, typename _Resolver>

    class ResolverReader : public ResolverReaderBase<_Item> {

    public:

      typedef _Item Item;

      typedef _Resolver Resolver;

      const Resolver& resolver;

      ResolverReader(const Resolver& _resolver) 

	: resolver(_resolver) {}

      virtual Item resolve(std::istream& is) const {

	return resolver.resolve(is);

      }

    };

    class ValueReaderBase {

    public:

      virtual void read(std::istream&) {};

    };

    template <typename _Value, typename _Reader>

    class ValueReader : public ValueReaderBase {

    public:

      typedef _Value Value;

      typedef _Reader Reader;

      ValueReader(Value& _value, const Reader& _reader)

 	: value(_value), reader(_reader) {}

      virtual void read(std::istream& is) {

	reader.read(is, value);

      }

    private:

      Value& value;

      Reader reader;

    };

  };

  template <typename _Graph, typename _Traits = DefaultReaderTraits>

  class NodeSetReader : public CommonSectionReaderBase {

    typedef CommonSectionReaderBase Parent;

  public:

    typedef _Graph Graph;

    typedef _Traits Traits;

    typedef typename Graph::Node Item;

    typedef typename Traits::Skipper DefaultSkipper;

    NodeSetReader(LemonReader& _reader, Graph& _graph, 

		  const std::string& _id = std::string(),

		  const DefaultSkipper& _defreader = DefaultSkipper()) 

      : graph(_graph), id(_id), skipper(_defreader) {

      _reader.attach(*this);

    } 

    virtual ~NodeSetReader() {

      for (typename MapReaders::iterator it = readers.begin(); 

	   it != readers.end(); ++it) {

	delete it->second;

      }

    }

  private:

    NodeSetReader(const NodeSetReader&);

    void operator=(const NodeSetReader&);

  public:

    /// \brief Add a new node map reader command for the reader.

    ///

    /// Add a new node map reader command for the reader.

    template <typename Map>

    NodeSetReader& readMap(std::string name, Map& map) {

      return readMap<typename Traits::

	template Reader<typename Map::Value>, Map>(name, map);

    }

    /// \brief Add a new node map reader command for the reader.

    ///

    /// Add a new node map reader command for the reader.

    template <typename Reader, typename Map>

    NodeSetReader& readMap(std::string name, Map& map, 

			     const Reader& reader = Reader()) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for node map: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(

	make_pair(name, new MapReader<Item, Map, Reader>(map, reader)));

      return *this;

    }

    /// \brief Add a new node map skipper command for the reader.

    ///

    /// Add a new node map skipper command for the reader.

    template <typename Reader>

    NodeSetReader& skipMap(std::string name, 

			   const Reader& reader = Reader()) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for node map: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader)));

      return *this;

    }

    /// \e

    virtual bool header(const std::string& line) {

      std::istringstream ls(line);

      std::string command;

      std::string name;

      ls >> command >> name;

      return command == "@nodeset" && name == id;

    }

    /// \e

    virtual void read(std::istream& is) {

      std::vector<ReaderBase<Item>* > index;

      std::string line;

      getline(is, line);

      std::istringstream ls(line);	

      while (ls >> id) {

	typename MapReaders::iterator it = readers.find(id);

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

	  index.push_back(it->second);

	} else {

	  index.push_back(&skipper);

	}

	if (id == "id" && inverter.get() == 0) {

	  inverter.reset(index.back()->getInverter());

	  index.back() = inverter.get();

	}

      }

      while (getline(is, line)) {	

	typename Graph::Node node = graph.addNode();

	std::istringstream ls(line);

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

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

	}

      }

    }

    bool isResolver() const {

      return inverter.get() != 0;

    }

    typename Graph::Node resolve(std::istream& is) const {

      return inverter->read(is);

    } 

  private:

    typedef std::map<std::string, ReaderBase<Item>*> MapReaders;

    MapReaders readers;

    Graph& graph;   

    std::string id;

    SkipReader<Item, DefaultSkipper> skipper;

    std::auto_ptr<InverterBase<Item> > inverter;

  };

  /// \e

  template <typename _Graph, typename _Traits = DefaultReaderTraits>

  class EdgeSetReader : public CommonSectionReaderBase {

    typedef CommonSectionReaderBase Parent;

  public:

    typedef _Graph Graph;

    typedef _Traits Traits;

    typedef typename Graph::Edge Item;

    typedef typename Traits::Skipper DefaultSkipper;

    template <typename Resolver>

    EdgeSetReader(LemonReader& _reader, Graph& _graph, 

		  const Resolver& _nodeResolver, 

		  const std::string& _id = std::string(),

		  const DefaultSkipper& _defreader = DefaultSkipper()) 

      : graph(_graph), id(_id), skipper(_defreader),

      nodeResolver(new ResolverReader<typename Graph::Node, Resolver>

		   (_nodeResolver)) {

      _reader.attach(*this);

    } 

    virtual ~EdgeSetReader() {

      for (typename MapReaders::iterator it = readers.begin(); 

	   it != readers.end(); ++it) {

	delete it->second;

      }

    }

  private:

    EdgeSetReader(const EdgeSetReader&);

    void operator=(const EdgeSetReader&);

  public:

    /// \brief Add a new node map reader command for the reader.

    ///

    /// Add a new node map reader command for the reader.

    template <typename Map>

    EdgeSetReader& readMap(std::string name, Map& map) {

      return readMap<typename Traits::

	template Reader<typename Map::Value>, Map>(name, map);

    }

    /// \brief Add a new node map reader command for the reader.

    ///

    /// Add a new node map reader command for the reader.

    template <typename Reader, typename Map>

    EdgeSetReader& readMap(std::string name, Map& map, 

			     const Reader& reader = Reader()) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for edge map: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(

	make_pair(name, new MapReader<Item, Map, Reader>(map, reader)));

      return *this;

    }

    /// \brief Add a new node map skipper command for the reader.

    ///

    /// Add a new node map skipper command for the reader.

    template <typename Reader>

    EdgeSetReader& skipMap(std::string name, 

			   const Reader& reader = Reader()) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for node map: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(make_pair(name, new SkipReader<Item, Reader>(reader)));

      return *this;

    }

    /// \e

    virtual bool header(const std::string& line) {

      std::istringstream ls(line);

      std::string command;

      std::string name;

      ls >> command >> name;

      return command == "@edgeset" && name == id;

    }

    /// \e

    virtual void read(std::istream& is) {

      std::vector<ReaderBase<Item>* > index;

      std::string line;

      getline(is, line);

      std::istringstream ls(line);	

      while (ls >> id) {

	typename MapReaders::iterator it = readers.find(id);

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

	  index.push_back(it->second);

	} else {

	  index.push_back(&skipper);

	}

	if (id == "id" && inverter.get() == 0) {

	  inverter.reset(index.back()->getInverter());

	  index.back() = inverter.get();

	}

      }

      while (getline(is, line)) {	

	std::istringstream ls(line);

	typename Graph::Node from = nodeResolver->resolve(ls);

	typename Graph::Node to = nodeResolver->resolve(ls);

	typename Graph::Edge edge = graph.addEdge(from, to);

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

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

	}

      }

    }

    bool isResolver() const {

      return inverter.get() != 0;

    }

    typename Graph::Edge resolve(std::istream& is) {

      return inverter->read(is);

    } 

  private:

    typedef std::map<std::string, ReaderBase<Item>*> MapReaders;

    MapReaders readers;

    Graph& graph;   

    std::string id;

    SkipReader<Item, DefaultSkipper> skipper;

    std::auto_ptr<InverterBase<Item> > inverter;

    std::auto_ptr<ResolverReaderBase<typename Graph::Node> > nodeResolver;

  };

  /// \e

  template <typename _Traits = DefaultReaderTraits>

  class AttributeReader : public CommonSectionReaderBase {

    typedef CommonSectionReaderBase Parent;

    typedef _Traits Traits; 

  public:

    /// \e

    AttributeReader(LemonReader& _reader, 

		    const std::string& _id = std::string()) : id(_id) {

      _reader.attach(*this);

    }

    /// \e

    virtual ~AttributeReader() {

      for (typename Readers::iterator it = readers.begin(); 

	   it != readers.end(); ++it) {

	delete it->second;

      }

    }

  private:

    AttributeReader(const AttributeReader&);

    void operator=(AttributeReader&);

  public:

    /// \e

    template <typename Value>

    AttributeReader& readAttribute(const std::string& id, Value& value) {

      return readAttribute<typename Traits::template Reader<Value> >

	(id, value);

    }

    /// \e

    template <typename Reader, typename Value>

    AttributeReader& readAttribute(const std::string& name, Value& value,

				   const Reader& reader = Reader()) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for attribute: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(make_pair(name, new ValueReader<Value, Reader>

      			       (value, reader)));

      return *this;

    }

    /// \e

    bool header(const std::string& line) {

      std::istringstream ls(line);

      std::string command;

      std::string name;

      ls >> command >> name;

      return command == "@attributes" && name == id;

    }

    /// \e

    void read(std::istream& is) {

      std::string line;

      while (getline(is, line)) {

	std::istringstream ls(line);

	std::string id;

	ls >> id;

	typename Readers::iterator it = readers.find(id);

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

	  it->second->read(ls);

	}

      }

    }    

  private:

    std::string id;

    typedef std::map<std::string, ValueReaderBase*> Readers;

    Readers readers;

  };

  template <typename _Graph>

  class NodeReader : public CommonSectionReaderBase {

    typedef CommonSectionReaderBase Parent;

    typedef _Graph Graph;

    typedef typename Graph::Node Item;

  public:

    template <typename Resolver>

    NodeReader(LemonReader& _reader, const Resolver& _resolver, 

	       const std::string& _id = std::string()) 

      : id(_id), resolver(new ResolverReader<typename Graph::Node, Resolver>

		     (_resolver)) {

      _reader.attach(*this);

    } 

    virtual ~NodeReader() {}

  private:

    NodeReader(const NodeReader&);

    void operator=(const NodeReader&);

  public:

    void readNode(const std::string& name, Item& item) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for node: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(make_pair(name, &item));

    }

    virtual bool header(const std::string& line) {

      std::istringstream ls(line);

      std::string command;

      std::string name;

      ls >> command >> name;

      return command == "@nodes" && name == id;

    }

    virtual void read(std::istream& is) {

      std::string line;

      while (getline(is, line)) {

	std::istringstream ls(line);

	std::string id;

	ls >> id;

	typename ItemReaders::iterator it = readers.find(id);

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

	  *(it->second) = resolver->resolve(ls); 

	}	

      }

    }

  private:

    std::string id;

    typedef std::map<std::string, Item*> ItemReaders;

    ItemReaders readers;

    std::auto_ptr<ResolverReaderBase<Item> > resolver;

  };

  template <typename _Graph>

  class EdgeReader : public CommonSectionReaderBase {

    typedef CommonSectionReaderBase Parent;

    typedef _Graph Graph;

    typedef typename Graph::Edge Item;

  public:

    template <typename Resolver>

    EdgeReader(LemonReader& _reader, const Resolver& _resolver, 

	       const std::string& _id = std::string()) 

      : id(_id), resolver(new ResolverReader<typename Graph::Node, Resolver>

		     (_resolver)) {

      _reader.attach(*this);

    } 

    virtual ~EdgeReader() {}

  private:

    EdgeReader(const EdgeReader&);

    void operator=(const EdgeReader&);

  public:

    void readEdge(const std::string& name, Item& item) {

      if (readers.find(name) != readers.end()) {

	ErrorMessage msg;

	msg << "Multiple read rule for edge: " << name;

	throw IOParameterError(msg.message());

      }

      readers.insert(make_pair(name, &item));

    }

    virtual bool header(const std::string& line) {

      std::istringstream ls(line);

      std::string command;

      std::string name;

      ls >> command >> name;

      return command == "@nodes" && name == id;

    }

    virtual void read(std::istream& is) {

      std::string line;

      while (getline(is, line)) {

	std::istringstream ls(line);

	std::string id;

	ls >> id;

	typename ItemReaders::iterator it = readers.find(id);

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

	  *(it->second) = resolver->resolve(ls); 

	}	

      }

    }

  private:

    std::string id;

    typedef std::map<std::string, Item*> ItemReaders;

    ItemReaders readers;

    std::auto_ptr<ResolverReaderBase<Item> > resolver;

  };

  /// \e

  class PrintReader : public LemonReader::SectionReader {

    typedef LemonReader::SectionReader Parent;

  public:

    /// \e

    PrintReader(LemonReader& reader) {

      reader.attach(*this);

    }

    /// \e

    bool header(const std::string& line) {

      std::cout << "Asked header: " << line << std::endl; 

      return true;

    }

    /// \e

    void read(std::istream& is) {

      std::string line;

      while (std::getline(is, line)) {

	std::cout << line << std::endl;

      }

    }

  };

  /// @}

}

#endif