#include<lemon/xy.h>

 #include<lemon/maps.h>

 #include<lemon/list_graph.h>

 ///\file

 ///Simple graph drawer

 namespace lemon {

   ///\e

 class Color

 {

   double _r,_g,_b;

 public:

   ///\e

   Color() {}

   ///\e

   Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};

   ///\e

   double getR() {return _r;}

   ///\e

   double getG() {return _g;}

   ///\e

   double getB() {return _b;}

   ///\e

   void set(double r,double g,double b) { _r=r;_g=g;_b=b; };

 };

   ///\e

 template<class G>

 struct DefaultGraphToEpsTraits

 {

   typedef G Graph;

   typedef typename Graph::Node Node;

   typedef typename Graph::NodeIt NodeIt;

   typedef typename Graph::Edge Edge;

   typedef typename Graph::EdgeIt EdgeIt;

   typedef typename Graph::InEdgeIt InEdgeIt;

   typedef typename Graph::OutEdgeIt OutEdgeIt;

   const Graph &g;

   ConstMap<typename Graph::Node,xy<double> > coords;

   ConstMap<typename Graph::Node,double > nodeSizes;

   ConstMap<typename Graph::Node,Color > nodeColors;

   ConstMap<typename Graph::Edge,Color > edgeColors;

   double nodeSizeScalar;

   double xBorder, yBorder;

   DefaultGraphToEpsTraits(G &_g) :

     g(_g), coords(xy<double>(1,1)), nodeSizes(1.0),

     nodeColors(Color(1,1,1)), edgeColors(Color(0,0,0)),

     nodeSizeScalar(1.0), xBorder(10), yBorder(10) {}

 };

   ///\e

 template<class T> class GraphToEps : public T 

 {

   typedef typename T::Graph Graph;

   typedef typename Graph::Node Node;

   typedef typename Graph::NodeIt NodeIt;

   typedef typename Graph::Edge Edge;

   typedef typename Graph::EdgeIt EdgeIt;

   typedef typename Graph::InEdgeIt InEdgeIt;

   typedef typename Graph::OutEdgeIt OutEdgeIt;

   bool dontPrint;

 public:

   GraphToEps(const T &t) : T(t), dontPrint(false) {};

   template<class X> struct SetCoordsTraits : public T {

     const X &coords;

     SetCoordsTraits(const T &t,const X &x) : T(t), coords(x) {}

   };

   ///\e

   template<class X> GraphToEps<SetCoordsTraits<X> > setCoords(const X &x) {

     dontPrint=true;

     return GraphToEps<SetCoordsTraits<X> >(SetCoordsTraits<X>(*this,x));

   }

   template<class X> struct SetNodeSizesTraits : public T {

     const X &nodeSizes;

     SetNodeSizesTraits(const T &t,const X &x) : T(t), nodeSizes(x) {}

   };

   ///\e

   template<class X> GraphToEps<SetNodeSizesTraits<X> > setNodeSizes(const X &x)

   {

     dontPrint=true;

     return GraphToEps<SetNodeSizesTraits<X> >(SetNodeSizesTraits<X>(*this,x));

   }

   template<class X> struct SetNodeColorsTraits : public T {

     const X &nodeColors;

     SetNodeColorsTraits(const T &t,const X &x) : T(t), nodeColors(x) {}

   };

   ///\e

   template<class X> GraphToEps<SetNodeColorsTraits<X> >

   setNodeColors(const X &x)

   {

     dontPrint=true;

     return GraphToEps<SetNodeColorsTraits<X> >(SetNodeColorsTraits<X>(*this,x));

   }

   template<class X> struct SetEdgeColorsTraits : public T {

     const X &edgeColors;

     SetEdgeColorsTraits(const T &t,const X &x) : T(t), edgeColors(x) {}

   };

   ///\e

   template<class X> GraphToEps<SetEdgeColorsTraits<X> >

   setEdgeColors(const X &x)

   {

     dontPrint=true;

     return GraphToEps<SetEdgeColorsTraits<X> >(SetEdgeColorsTraits<X>(*this,x));

   }

   ///\e

   GraphToEps<T> &scaleNodeSize(double d) {nodeSizeScalar=d;return *this;}

   ~GraphToEps() 

   {

     if(dontPrint) return;

     cout << "%!PS-Adobe-2.0 EPSF-2.0\n";

     //\todo: Chech whether the graph is empty.

     BoundingBox<double> bb;

     for(NodeIt n(g);

 	n!=INVALID;

 	++n) {

       xy<double> p(nodeSizes[n]*nodeSizeScalar,nodeSizes[n]*nodeSizeScalar);

       bb+=coords[n]+p;

       bb+=coords[n]-p;

       }

     cout << "%%BoundingBox: "

 	 << bb.left()-xBorder << ' ' << bb.bottom()-yBorder << ' '

 	 << bb.right()+xBorder << ' ' << bb.top()+yBorder << '\n';

     //x1 y1 x2 y2 cr cg cb

     cout << "/l { setrgbcolor newpath moveto lineto stroke } bind def\n";

     cout << "/c { newpath dup 3 index add 2 index moveto 0 360 arc } bind def\n";

     // x y r cr cg cb

     cout << "/n { setrgbcolor 2 index 2 index 2 index c fill\n"

 	 << "     0 0 0 setrgbcolor dup 10 div setlinewidth c stroke\n"

 	 << "   } bind def\n";

     cout << "%Edges:\ngsave\n";

     for(NodeIt n(g);n!=INVALID;++n)

       for(OutEdgeIt e(g,n);e!=INVALID;++e)

 	cout << coords[g.source(e)].x << ' ' << coords[g.source(e)].y << ' '

 	     << coords[g.target(e)].x << ' ' << coords[g.target(e)].y << ' '

 	     << edgeColors[e].getR() << ' '

 	     << edgeColors[e].getG() << ' '

 	     << edgeColors[e].getB() << " l\n";

     cout << "grestore\n%Nodes:\ngsave\n";

     for(NodeIt n(g);n!=INVALID;++n)

       cout << coords[n].x << ' ' << coords[n].y << ' '

 	   << nodeSizes[n]*nodeSizeScalar << ' '

 	   << nodeColors[n].getR() << ' '

 	   << nodeColors[n].getG() << ' '

 	   << nodeColors[n].getB() << " n\n"; 

     cout << "grestore\n";

   } 

 };

 template<class G>

 GraphToEps<DefaultGraphToEpsTraits<G> > graphToEps(G &g)

 {

   return GraphToEps<DefaultGraphToEpsTraits<G> >(DefaultGraphToEpsTraits<G>(g));

 }

 }

 using namespace lemon;

 class ColorSet : public MapBase<int,Color>

 {

 public:

   Color operator[](int i) const

   {

     switch(i%8){

     case 0: return Color(0,0,0);

     case 1: return Color(1,0,0);

     case 2: return Color(0,1,0);

     case 3: return Color(0,0,1);

     case 4: return Color(1,1,0);

     case 5: return Color(1,0,1);

     case 6: return Color(0,1,1);

     case 7: return Color(1,1,1);

     }

     return Color(0,0,0);

   }

 } colorSet;

 int main()

 {

   ListGraph g;

   typedef ListGraph::Node Node;

   typedef ListGraph::NodeIt NodeIt;

   typedef ListGraph::Edge Edge;

   typedef xy<double> Xy;

   Node n1=g.addNode();

   Node n2=g.addNode();

   Node n3=g.addNode();

   Node n4=g.addNode();

   Node n5=g.addNode();

   ListGraph::NodeMap<Xy> coords(g);

   ListGraph::NodeMap<double> sizes(g);

   ListGraph::NodeMap<int> colors(g);

   ListGraph::EdgeMap<int> ecolors(g);

   coords[n1]=Xy(50,50);  sizes[n1]=1; colors[n1]=1;

   coords[n2]=Xy(50,70);  sizes[n2]=2; colors[n2]=2;

   coords[n3]=Xy(70,70);  sizes[n3]=1; colors[n3]=3;

   coords[n4]=Xy(70,50);  sizes[n4]=2; colors[n4]=4;

   coords[n5]=Xy(85,60);  sizes[n5]=3; colors[n5]=5;

   Edge e;

   e=g.addEdge(n1,n2); ecolors[e]=0;

   e=g.addEdge(n2,n3); ecolors[e]=0;

   e=g.addEdge(n3,n5); ecolors[e]=0;

   e=g.addEdge(n5,n4); ecolors[e]=0;

   e=g.addEdge(n4,n1); ecolors[e]=0;

   e=g.addEdge(n2,n4); ecolors[e]=1;

   e=g.addEdge(n3,n4); ecolors[e]=2;

   graphToEps(g).setCoords(coords).

     scaleNodeSize(2).setNodeSizes(sizes).

     setNodeColors(composeMap(colorSet,colors)).

     setEdgeColors(composeMap(colorSet,ecolors));

 }