/* -*- C++ -*- */

#include <iostream>

#include <string>

#include <vector>

#include <list>

#include <map>

#include <lemon/error.h>

#include <lemon/xy.h>

namespace lemon {

  class XmlWriter 

  {

    std::ostream& os;

    int level;

  protected:

    void indent(int level) {

      os << std::endl;

      for(int i=0;i<level;i++) os << ' ';

    }

    void tag(const std::string &_tag) {

      os << '<' << _tag << '>';

    }

    void etag(const std::string &_tag) {

      os << "</" << _tag << '>';

    }

    void itag(const std::string &_tag) { indent();tag(_tag); }

    void ietag(const std::string &_tag) { indent();etag(_tag); }

    void beginTag(const std::string &_tag) {

      itag(_tag);

      level++;

    }

    void endTag(const std::string &_tag) {

      level--;

      ietag(_tag);

    }

  public:

    void indent() 

    {

      if(level>=0) indent(level);

      else level=0;

    }

    ///\e

    ///\e

    ///

    class ContTag

    {

      XmlWriter &ix;

      const std::string _tag;

    public:

      ///\e

      ///\e

      ///

      ContTag(XmlWriter &_ix,const std::string &_t) :

	ix(_ix), _tag(_t)

      {

	ix.tag(_tag);

      }

      ~ContTag() { ix.etag(_tag);}

    };

    class LineTag

    {

      XmlWriter &ix;

      const std::string _tag;

    public:

      ///\e

      ///\e

      ///

      LineTag(XmlWriter &_ix,const std::string &_t) :

	ix(_ix), _tag(_t)

      {

	ix.itag(_tag);

      }

      ~LineTag() { ix.etag(_tag);}

    };

    ///\e

    ///\e

    ///

    class Tag

    {

      XmlWriter &ix;

      const std::string _tag;

    public:

      ///\e

      ///\e

      ///

      Tag(XmlWriter &_ix,const std::string &_t) :

	ix(_ix), _tag(_t)

      {

	ix.beginTag(_tag);

      }

      ~Tag() { 

	ix.endTag(_tag);

      }

    };

    ///\e

    ///\e

    ///

    XmlWriter(std::ostream& _os) : os(_os),level(-1) {}

    ~XmlWriter() { os<< std::endl; }

    XmlWriter &operator()(int v) 

    { 

      os << v;

      return *this;

    }

    XmlWriter &operator()(const std::string &_tag,int v) 

    { 

      LineTag t(*this,_tag);

      (*this)(v);

      return *this;

    }

    XmlWriter &operator()(double v) 

    {

      os << v;

      return *this;

    }

    XmlWriter &operator()(const std::string &_tag,double v) 

    {

      LineTag t(*this,_tag);

      (*this)(v);

      return *this;

    }

    XmlWriter &operator()(const std::string &v)

    {

      for(std::string::const_iterator i=v.begin();i!=v.end();++i)

	switch(*i) {

	case '\\':

	  os << "\\\\";

	  break;

	case '<':

	  os << "\\<";

	  break;

	case '&':

	  os << "\\&";

	  break;

	case '\n':

	  os << "\\n";

	  break;

	default:

	  os<<*i;

	  break;

	}

      return *this;

    }

    XmlWriter &operator()(const std::string &_tag,const std::string &v)

    {

      LineTag t(*this,_tag);

      (*this)(v);

      return *this;

    }

    ///\e

    ///\e

    ///

    template<class V>

    XmlWriter &operator()(const std::string &_tag,const V &v)

    {

      Tag t(*this,_tag);

      out(*this,v);

      return *this;

    }

    ///\e

    ///\e

    ///

    template<class V>

    XmlWriter &operator()(const V &v)

    {

      out(*this,v);

      return *this;

    }

  };

  //////////////////////////////////////////////////////////////////////

  class XmlReader 

  {

    std::istream& is;

    std::string next_tag;

    int line_number;

    void skipWhiteSpaces()

    {

      char c;

      while (is.get(c) && std::isspace(c,is.getloc())) if(c=='\n') line_number++;

      is.unget();

    }

  protected:

    ///\e

    ///\e

    ///

    void useTag() {next_tag.clear();}

    void useTag(const std::string &_tag) {

      if(nextTag()==_tag) useTag();

      else throw DataFormatError("",line_number,"Unexpected token name");

    }

  public:

    ///\e

    ///\e

    ///

    const std::string &nextTag() 

    {

      if(next_tag.empty()) {

	char c;

	skipWhiteSpaces();

	if(!is.get(c) || c!='<')

	  throw DataFormatError("",line_number,"Bad token");

	next_tag.clear();

	while (is.get(c) && c!='>') next_tag.push_back(c);

	if(c!='>')

	  throw DataFormatError("",line_number,"Bad token");

      }

      return next_tag;

    }

    ///\e

    ///\e

    ///

    class Tag

    {

      XmlReader &ix;

      const std::string tag;

    public:

      ///\e

      ///\e

      ///

      Tag(XmlReader &_ix,const std::string &_tag) :

	ix(_ix), tag(_tag)

      {

	ix.useTag(_tag);

      }

      ~Tag() {

	if(!std::uncaught_exception()) 

	  ix.useTag('/'+tag);

      }

    };

    ///\e

    ///\e

    ///

    XmlReader(std::istream& _is) : is(_is), line_number(1) {}

    int operator()(const std::string &tag,int &v)

    { 

      Tag t(*this,tag);

      skipWhiteSpaces();

      if(!(is >> v)) throw DataFormatError("",line_number,"Not an 'int'");

      return v;

    }

    double operator()(const std::string &tag,double &v) 

    {

      Tag t(*this,tag);

      skipWhiteSpaces();

      if(!(is >> v))

	throw DataFormatError("",line_number,"Not a 'double'");

      return v;

    }

    std::string &operator()(const std::string &tag,std::string &v)

    {

      Tag t(*this,tag);

      v.clear();

      char c;

      while (is.get(c) && c!='<')

	if(c=='\\')

	  if(!is.get(c))

	    throw DataFormatError("",line_number,"Bad string");

	  else switch(c) {

	  case 'n':

	    v.push_back('\n');

	    break;

	  default:

	    v.push_back(c);

	    break;

	  }

	else {

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

	  v.push_back(c);

	}

      if(c!='<')

	throw DataFormatError("",line_number,"Unexpected eof");

      is.unget();

      return v;

    }

    ///\e

    ///\e

    ///

    template<class V>

    V &operator()(const std::string &tag,V &v)

    {

      Tag t(*this,tag);

      in(*this,v);

      return v;

    }

    ///\e

    ///\e

    ///

    template<class V>

    V &operator()(V &v)

    {

      in(*this,v);

      return v;

    }

    ///\e

    ///\e

    ///

    template<class V>

    V load(const std::string &tag)

    {

      Tag t(*this,tag);

      V v;

      (*this)(tag,v);

      return v;

    }

  };

  //////////////////////////////////////////////////////////////////////

  template<class A>

  void out(XmlWriter &x,const std::auto_ptr<A> &v)

  {

    x(*v);

  }

  template<class A>

  void in(XmlReader &x,std::auto_ptr<A> &v)

  {

    v=new A;

    x(*v);

  }

  //////////////////////////////

  template<class A,class B>

  void out(XmlWriter &x,const std::pair<A,B> &v)

  {

    x("first",v.first);

    x("second",v.second);

  }

  template<class A,class B>

  void in(XmlReader &x,std::pair<A,B> &v)

  {

    x("first",v.first);

    x("second",v.second);

  }

  //////////////////////////////

  template<class T>

  void out(XmlWriter &x,const std::list<T> &v)

  {

    for(typename std::list<T>::const_iterator it=v.begin();

	it!=v.end();++it) x("item",*it);

  }

  template<class T>

  void in(XmlReader &x,std::list<T> &v)

  {

    while(x.nextTag()=="item")

      {

	v.push_back(T());

	x("item",v.back());

      }

  }

  //////////////////////////////

  template<class T>

  void out(XmlWriter &x,const std::vector<T> &v)

  {

    for(typename std::vector<T>::const_iterator it=v.begin();

	it!=v.end();++it) x("item",*it);

  }

  template<class T>

  void in(XmlReader &x,std::vector<T> &v)

  {

    while(x.nextTag()=="item")

      {

	v.push_back(T());

	x("item",v.back());      

      }

  }

  //////////////////////////////

  template<class K,class V>

  void out(XmlWriter &x,const std::map<K,V> &v)

  {

    for(typename std::map<K,V>::const_iterator it=v.begin();

	it!=v.end();++it) x("item",*it);

  }

  template<class K,class V>

  void in(XmlReader &x,std::map<K,V> &v)

  {

    while(x.nextTag()=="item")

      {

	typename std::map<K,V>::value_type it;

	x("item",it);

	v.insert(it);

      }

  }

  //////////////////////////////

  template<class T>

  void out(XmlWriter &x,const lemon::xy<T> &v)

  {

    //   x("x",v.x);

    //   x("y",v.y);

    { XmlWriter::LineTag t(x,"x"); x(v.x); }

    { XmlWriter::ContTag t(x,"y"); x(v.y); }

  }

  template<class T>

  void in(XmlReader &x,lemon::xy<T> &v)

  {

    x("x",v.x);

    x("y",v.y);

  }

  //////////////////////////////

  template<class T>

  void out(XmlWriter &x,const lemon::BoundingBox<T> &v)

  {

    if(!v.empty()) {

      x("point",v.bottomLeft());

      if(v.bottomLeft()!=v.topRight()) x("point",v.topRight());

    }

  }

  template<class T>

  void in(XmlReader &x,lemon::BoundingBox<T> &v)

  {

    v.clear();

    while(x.nextTag()=="point") {

      lemon::xy<T> co;

      x("point",co);

      v.add(co);

    }

  }

}