#ifndef RENDER_SVG
#define RENDER_SVG


#include <iostream>
#include <sstream>
#include <fstream>

#define BUFFER_SIZE 10 //character number stored before flush the _buffer
#define LEVEL 20        //distance between two containers
#define MARGIN 10        //distance between two object
#define ARROWSIZE 2      //spike size
#define WIDE 20
#define MARGINSTATE 0.5

#define WAIT_NEW_CHRONO 0
#define INIT 1
#define WAIT_FOR_POINT 2



#include "render.hpp"
#include "resource.hpp"


#define max(a,b) (a>b?a:b);
#define min(a,b) (a>b?b:a);

class Svg : public Render{


private:
    std::ostringstream _buffer;
    std::ostringstream _thin_element_buffer;
    std::ostringstream _chronogramme;
    int _chronogramme_state;
    std::ofstream _svg_file;
    Element_pos _container_width_max;
    Element_pos _container_height_min;
    int _debug_counter;
    double _epsilon;

    inline void print();
  inline void rectangle(const char* name,Element_pos w, Element_pos h,Element_pos x1,Element_pos y1,  unsigned int r,   unsigned int g,   unsigned int b );
    inline void line(const char* name, Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2);
    inline void triangle(const char* name,Element_pos x1,Element_pos y1,Element_pos x2,Element_pos y2, Element_pos x3,Element_pos y3);
public:
    /*!
     * \brief SVG header buiding
     */
    void init(const char *path);

    /*!
     * \brief SVG bottom file buiding
     */
    void end();

    void start_draw();
    void start_draw_containers();

    /*!
     * \brief Draw a container according to the parameters
     * \param x the x position of the container
     * \param y the y position of the container
     * \param w the width of the container
     * \param h the height of the container
     */
    void draw_container(const Element_pos x, const Element_pos y, const Element_pos w, const Element_pos h) ;

    void draw_container_text(const Element_pos x, const Element_pos y, const std::string value);

    void end_draw_containers();
    void start_draw_states();

    /*!
     * \brief Draw a state of the trace.
     * \param r the red color rate of the state.
     * \param g the green color rate of the state.
     * \param b the blue color rate of the state.
     * \param start the beginning time of the state.
     * \param end the ending time of the state.
     * \param level refer to the container which state belongs to.
     */
    void draw_state(const Element_pos start , const Element_pos end, const Element_pos level, const Element_pos height, const Element_col r, const Element_col g, const Element_col b) ;

    /*!
    * \brief Draw an arrow
    *
    */
    void draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height);

    void end_draw_states();

    void draw_event(const Element_pos time, const Element_pos height, const Element_pos container_height);

    void start_draw_counter();
    
    void draw_counter(const Element_pos x, const Element_pos y);
    
    void end_draw_counter();

    void end_draw();

    void set_accuracy(double epsilon);
};



/***********************************
 *
 *
 *
 * Drawing function for the trace.
 *
 *
 *
 **********************************/


inline void Svg::start_draw(){
 
}

inline void Svg::draw_container_text(const Element_pos x, const Element_pos y, const std::string value){
  
  Element_pos xprime,yprime;
  
  yprime = LEVEL*y;
  xprime = LEVEL*x;

  _thin_element_buffer << "<text x='" << xprime <<"' y='" << yprime << "'> ";
  _thin_element_buffer << value;
  _thin_element_buffer << "</text>";

} 

inline void Svg::start_draw_containers(){

}

inline void Svg::end_draw_containers(){
}

inline void Svg::start_draw_states(){
}

inline void Svg::end_draw_states(){
}


/********************
 * Counter
 *******************/

inline void Svg::start_draw_counter(){
  _chronogramme_state=INIT;
}

inline void Svg::draw_counter(const Element_pos x, const Element_pos y){

std::cout<<"s.draw_counter("<<x<<","<<y<<");\n";

  if (_chronogramme_state==INIT)
    {
      if (x==0)
	{
	  _chronogramme << "\n<path d='M0 "<< y;
	  _chronogramme_state=WAIT_FOR_POINT;
	}
      else
	std::cerr<<"draw_counter not initialised";
	  
    }
  else  if (_chronogramme_state==WAIT_FOR_POINT)
    
    {
      
      if (x==0)
	{
	  _chronogramme << "'/>";
	  _svg_file.write(_chronogramme.str().c_str(), _chronogramme.str().size());
	  _chronogramme.str("");
	  _chronogramme_state=WAIT_NEW_CHRONO;
	}
      else
	{
	  _chronogramme << " L" << x << " " << y;
	}
      
    }
  
  else  if (_chronogramme_state==WAIT_NEW_CHRONO)
    {
        if (x==0)
	{
	  _chronogramme << "\n<path d='M0 "<< y;
	  _chronogramme_state=WAIT_FOR_POINT;
	}
      else
	std::cerr<<"draw_counter not initialised";
	  

    }
  

}

inline void Svg::end_draw_counter(){
  if (_chronogramme_state!=WAIT_NEW_CHRONO)
    std::cerr<<"draw_counter not un-initialised";
}


inline void Svg::end_draw(){
    Svg::end();
}

void Svg::rectangle(const char* name,Element_pos w, Element_pos h,Element_pos x1,Element_pos y1,  unsigned int r,   unsigned int g,   unsigned int b ){
  _buffer << "\n<rect class='"<<name<<"' title='"<<name<<"' width='" << w
            <<"' height='"<< h
            <<"' x='"     << x1
            <<"' y='"     << y1
            <<"' fill='rgb("<<r<<","<<g<<","<<b
            <<")'/>";
    print();
}





void Svg::triangle(const char* name,Element_pos x1,Element_pos y1,Element_pos x2,Element_pos y2, Element_pos x3,Element_pos y3){
   _thin_element_buffer << "\n<polyline title='"<<name<<"' class='triangle' points='"
            <<        x1 << "," << y1
            << " " << x2 << "," << y2
            << " " << x3 << "," << y3
            <<"' />";
    
}

void Svg::print(){
    // if (_buffer.str().size()>BUFFER_SIZE){
        _svg_file.write(_buffer.str().c_str(),  _buffer.str().size());
	_buffer.str("");
}




inline void Svg::line(const char* name, Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2){
   _thin_element_buffer << "\n<line title='"<<name<<"' x1='" << x1
            <<"' y1='"     << y1
            <<"' x2='"     << x2
            <<"' y2='"     << y2
            <<"' />";
    print();
}

inline void Svg::draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height){

  //std::cout<<"s.draw_arrow("<<start_time<<","<<end_time<<","<<start_height<<","<< end_height<<");\n";

  Element_pos x1=(start_time )*WIDE +  _container_width_max ;
  Element_pos y1=start_height*LEVEL;
  Element_pos x2=(end_time)*WIDE+  _container_width_max;
  Element_pos y2=end_height*LEVEL;


  Svg::line("arrow",x1 ,y1 ,x2,y2);

  Svg::triangle("arrow",x2 ,y2+ARROWSIZE,x2 ,y2-ARROWSIZE,x2+ARROWSIZE,y2);//spike
  
}

inline void Svg::draw_container(const Element_pos x, const Element_pos y, const Element_pos w, const Element_pos h){

  Element_pos xprime,yprime,wprime,hprime;
  
  wprime = LEVEL*w;
  hprime = LEVEL*h;
  yprime = LEVEL*y;
  xprime = LEVEL*x;

  //std::cout<<"s.draw_container("<<x<<","<<y<<","<<w<<","<< h<<");\n";

  Svg::rectangle("container",wprime, hprime, xprime, yprime, 0xff, 0x44, 0xcc);
  
  _container_width_max = max(wprime+xprime+ MARGIN,_container_width_max);
  _container_height_min = min(hprime,_container_height_min);
}



inline void Svg::draw_state(const Element_pos start , const Element_pos end, const Element_pos level, const Element_pos height, const Element_col r, const Element_col g, const Element_col b){
  

  

  Element_pos w =end*WIDE-start*WIDE;
  Element_pos h = _container_height_min;
  Element_pos x = (start )*WIDE+  _container_width_max + MARGINSTATE;
  Element_pos y = level*LEVEL;

  if(w<_epsilon){
    //std::cerr<<"state width is null";
      return;
  }
  // if( debug_counter++<1000)
  // std::cout<<"s.draw_state("<<start<<","<<end<<","<<level<<","<< height<<","<<r<<","<<g<<","<< b  <<");\n";
 
  Svg::rectangle("state",w,h, x,y,r*255 , g*255,  b*255);
}

inline  void Svg::draw_event(const Element_pos time, const Element_pos height, const Element_pos container_height){

  // std::cout<<"s.draw_event("<<time<<","<< height<<","<<container_height<<");\n";

  Svg::rectangle("event",MARGIN,container_height, time +  _container_width_max , height, 0x17, 0x60, 0xe7);
}




#endif // RENDER_SVG