// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_sg_plots
#define tools_sg_plots

#include "_switch"
#include "head_light"
#include "matrix"

#include "plotter"

namespace tools {
namespace sg {

class plots : public node {
  TOOLS_NODE(plots,tools::sg::plots,node)
public:
  sf<float> width;
  sf<float> height;
  sf<unsigned int> cols; //must never be 0.
  sf<unsigned int> rows; //must never be 0.
  sf<bool> view_border; //current plotter border
  sf<float> plotter_scale; //scale factor applied to each plotter.

  sf<bool> border_visible;
  sf<float> border_width;
  sf<float> border_height;
  sf_vec<colorf,float> border_color;
public:
  virtual const std::vector<field_desc>& node_fields() const {
    TOOLS_FIELD_DESC_NODE_CLASS(tools::sg::plots)
    static std::vector<field_desc> s_v;
    if(s_v.empty()) {
      s_v = parent::node_fields();
      TOOLS_ADD_FIELD_DESC(width)
      TOOLS_ADD_FIELD_DESC(height)
      TOOLS_ADD_FIELD_DESC(cols)
      TOOLS_ADD_FIELD_DESC(rows)
      TOOLS_ADD_FIELD_DESC(view_border)
      TOOLS_ADD_FIELD_DESC(plotter_scale)
      TOOLS_ADD_FIELD_DESC(border_visible)
      TOOLS_ADD_FIELD_DESC(border_width)
      TOOLS_ADD_FIELD_DESC(border_height)
      TOOLS_ADD_FIELD_DESC(border_color)
    }
    return s_v;
  }
private:
  void add_fields(){
    add_field(&width);
    add_field(&height);
    add_field(&cols);
    add_field(&rows);
    add_field(&view_border);
    add_field(&plotter_scale);
    add_field(&border_visible);
    add_field(&border_width);
    add_field(&border_height);
    add_field(&border_color);
  }
private:
  static unsigned int MATRIX()  {return 0;}
  static unsigned int LIGHT()   {return 1;}
  static unsigned int BORDER()  {return 2;}
  //static unsigned int TSF()     {return 3;}
  static unsigned int PLOTTER() {return 3;}

  typedef std::vector<plottable*> ptbs_t;
  typedef std::vector<node*> todels_t;
public:
  class updater { 
  public:
    virtual void update(plots&,size_t) = 0;
    virtual updater* copy() const = 0;
  public:
    virtual ~updater(){}
  };

public:
  virtual void render(render_action& a_action) {
    if(touched()) {
      update_sg();
      reset_touched();
    }
    m_group.render(a_action);
  }
  virtual void pick(pick_action& a_action) {
    if(touched()) {
      update_sg();
      reset_touched();
    }
    nodekit_pick(a_action,m_group,this);
    //m_group.pick(a_action);
  }
  virtual void search(search_action& a_action) {
    parent::search(a_action);
    if(a_action.done()) return;
    if(touched()) {
      update_sg();
      reset_touched();
    }
    if(a_action.do_path()) a_action.path_push(this);
    m_group.search(a_action);
    if(a_action.done()) return;
    if(a_action.do_path()) a_action.path_pop();
  }
  virtual void bbox(bbox_action& a_action) {
    if(touched()) {
      update_sg();
      reset_touched();
    }
    m_group.bbox(a_action);
  }

  virtual void event(event_action& a_action) {
    if(touched()) {
      update_sg();
      reset_touched();
    }
    m_group.event(a_action);
    if(a_action.done()) return;
  }
  virtual bool write(write_action& a_action) {
    if(touched()) {
      update_sg();
      reset_touched();
    }
    return m_group.write(a_action);
  }
public:
  plots(const base_freetype& a_ttf)
  :parent()
  ,width(1)
  ,height(1)
  ,cols(1)
  ,rows(1)
  ,view_border(true)
  ,plotter_scale(1)
  ,border_visible(false)
  ,border_width(0)
  ,border_height(0)
  ,border_color(colorf_grey())

  ,m_ttf(a_ttf)
  ,m_current(0)
  ,m_updater(0)
  ,m_old_cols(0)
  ,m_old_rows(0)
  {
    add_fields();
    init_sg();
  }
  virtual ~plots() {
    delete m_updater;
  }
public:
  plots(const plots& a_from)
  :parent(a_from)
  ,width(a_from.width)
  ,height(a_from.height)
  ,cols(a_from.cols)
  ,rows(a_from.rows)
  ,view_border(a_from.view_border)
  ,plotter_scale(a_from.plotter_scale)
  ,border_visible(a_from.border_visible)
  ,border_width(a_from.border_width)
  ,border_height(a_from.border_height)
  ,border_color(a_from.border_color)

  ,m_ttf(a_from.m_ttf)
  ,m_current(a_from.m_current)
  ,m_updater(0)
  ,m_old_cols(0)
  ,m_old_rows(0)
  {
    add_fields();
    init_sg();

    m_updater = a_from.m_updater?a_from.m_updater->copy():0;
  }
  plots& operator=(const plots& a_from){    
    parent::operator=(a_from);
    if(&a_from==this) return *this;

    width = a_from.width;
    height = a_from.height;

    cols = a_from.cols;
    rows = a_from.rows;
    view_border = a_from.view_border;
    plotter_scale = a_from.plotter_scale;

    border_visible = a_from.border_visible;
    border_width = a_from.border_width;
    border_height = a_from.border_height;
    border_color = a_from.border_color;

    m_old_cols = 0;
    m_old_rows = 0;

    m_current = a_from.m_current;

    return *this;
  }
public:
  unsigned int number() const {return cols*rows;}
  unsigned int current_index() const {return m_current;}
  
  void adjust_size(unsigned int a_ww,unsigned int a_wh) {
    if(!a_ww||!a_wh) return;
    float aspect = float(a_ww)/float(a_wh);
    width = height * aspect;

    //wps : cooking to avoid seeing a line for left border.
    width = width * 1.001f;

    update_sg();
    reset_touched();
  }  

public:
  void set_updater(updater* a_updater) {
    //WARNING : we take ownership of a_updater
    delete m_updater;
    m_updater = a_updater;
  }

  void clear() {
    if(m_sep.empty()) update_sg();
    size_t _number = m_sep.size();    
    for(size_t index=0;index<_number;index++) {
      reg_t* sep = (reg_t*)m_sep[index];
      plotter* _plotter = (plotter*)(*sep)[PLOTTER()];
      _plotter->clear();
    }    
  }

  bool has_data() {
    if(m_sep.empty()) update_sg();
    size_t _number = m_sep.size();    
    for(size_t index=0;index<_number;index++) {
      reg_t* sep = (reg_t*)m_sep[index];
      plotter* _plotter = (plotter*)(*sep)[PLOTTER()];
      if(_plotter->plottables().size()) return true;
    }    
    return false;
  }

  void touch_plotters() { //used in exlib/geant4/session.
    if(m_sep.empty()) update_sg();
    size_t _number = m_sep.size();    
    for(size_t index=0;index<_number;index++) {
      reg_t* sep = (reg_t*)m_sep[index];
      plotter* _plotter = (plotter*)(*sep)[PLOTTER()];
      _plotter->touch();
    }    
  }

  void next() {
    if(m_sep.empty()) update_sg();
    size_t _number = m_sep.size();    
    if(m_current>=(uint32(_number)-1)) {
      m_current = 0;
    } else {
      m_current++;
    }
    update_current_border();
  }

  bool set_current_plotter(unsigned int a_index) {
    if(m_sep.empty()) update_sg();
    if(a_index>=m_sep.size()) return false;
    m_current = a_index;
    update_current_border();
    return true;
  }

  bool set_current(plotter* a_plotter) { //for popup.
    if(m_sep.empty()) update_sg();
    size_t _number = m_sep.size();    
    for(size_t index=0;index<_number;index++) {
      reg_t* sep = (reg_t*)m_sep[index];
      plotter* _plotter = (plotter*)(*sep)[PLOTTER()];
      if(_plotter==a_plotter) {
        m_current = uint32(index);
        update_current_border();
        return true;
      }
    }    
    return false;
  }

  torche* current_torche() {
    if(m_sep.empty()) update_sg();
    reg_t* sep = (reg_t*)m_sep[m_current];
    return safe_cast<node,torche>(*((*sep)[LIGHT()]));
  }

/*
  matrix* current_tsf() {
    plotter& _plotter = current_plotter();
    if(_plotter.shape.value()==plotter::xyz) {
      return &(_plotter.tsf());
    } else {
      if(m_sep.empty()) update_sg();
      reg_t* sep = (reg_t*)m_sep[m_current];
      return safe_cast<node,matrix>(*((*sep)[TSF()]));
    }
  }
*/

  plotter& current_plotter() {
    if(m_sep.empty()) update_sg();
    reg_t* sep = (reg_t*)m_sep[m_current];
    return *((plotter*)(*sep)[PLOTTER()]);
  }
  plotter* find_plotter(unsigned int a_index) {
    if(m_sep.empty()) update_sg();
    if(a_index>=m_sep.size()) return 0;
    reg_t* sep = (reg_t*)m_sep[a_index];
    return (plotter*)(*sep)[PLOTTER()];
  }

/*
  bool find_plotter(unsigned int a_ww,unsigned int a_wh,
                    float a_x,float a_y,
                    unsigned int& a_index) {
    if(touched()) {
      update_sg();
      reset_touched();
    }
    if(m_sep.empty()) update_sg();

    a_index = 0;

    if(!a_ww) return false;
    if(!a_wh) return false;

    float aspect = float(a_ww)/float(a_wh);

    // one region in pixels :
    unsigned int rw = (unsigned int)(float(a_ww)/float(cols.value()));
    unsigned int rh = (unsigned int)(float(a_wh)/float(rows.value()));
    float ra = float(rw)/float(rh);

    // all window wc :
    float wh_wc = 1;
    float ww_wc = wh_wc * aspect;

    // region size in window wc :
    float rh_wc = wh_wc/rows;
    float rw_wc = rh_wc*ra;

    unsigned int _number = m_sep.size();    
    for(unsigned int index=0;index<_number;index++) {
      unsigned int row = index/cols;
      unsigned int col = index-cols*row;

      float x = -ww_wc*0.5f + col * rw_wc + rw_wc * 0.5f;
      float y =  wh_wc*0.5f - row * rh_wc - rh_wc * 0.5f;

      if( ((x-rw_wc*0.5f)<a_x)&&(a_x<(x+rw_wc*0.5f)) &&
          ((y-rh_wc*0.5f)<a_y)&&(a_y<(y+rh_wc*0.5f)) ){
        a_index = index;
        return true;
      }
    }    

    return false;
  }  
*/

  void set_regions(unsigned int a_cols = 1,
                   unsigned int a_rows = 1,
                   bool a_transfer = false) {
    unsigned int oldn = cols*rows;

    std::vector<ptbs_t> ptbss;
    std::vector<todels_t> tdlss;

    std::vector< plotter > pls;
    if(a_transfer) {   
      ptbss.resize(oldn);
      tdlss.resize(oldn);
      pls.resize(oldn,plotter(m_ttf));
      for(unsigned int index=0;index<oldn;index++) {
        plotter* p = find_plotter(index);
        p->transfer_plottables(ptbss[index]);
        p->transfer_todels(tdlss[index]);
        pls[index] = *p; //have a copy (of styles).
      }
    }

    cols = a_cols?a_cols:1;
    rows = a_rows?a_rows:1;
    touch();
    update_sg();
    set_current_plotter(0);
    clear();
    if(view_border.value()) {
      view_border = (number()==1?false:true); 
    }
    if(a_transfer) {   
      //fill new plotters with old data :
      unsigned int num = tools::mn(oldn,cols*rows);
      for(unsigned int index=0;index<num;index++) {
        plotter* p = find_plotter(index);
        *p = pls[index];

       {const ptbs_t& ptbs = ptbss[index];
        ptbs_t::const_iterator it;
        for(it=ptbs.begin();it!=ptbs.end();++it) p->add_plottable(*it);}

       {const todels_t& todels = tdlss[index];
        todels_t::const_iterator it;
        for(it=todels.begin();it!=todels.end();++it) p->add_node_todel(*it);}
      }
    }

  }

  void current_to_one() {
    ptbs_t ptbs;
    current_plotter().transfer_plottables(ptbs);
    todels_t tdls;
    current_plotter().transfer_todels(tdls);
    plotter pl = current_plotter(); //have a copy (of styles).

    set_regions(1,1,false);

    plotter& p = current_plotter();
    p = pl; //copy styles.

   {ptbs_t::const_iterator it;
    for(it=ptbs.begin();it!=ptbs.end();++it) p.add_plottable(*it);}
   {todels_t::const_iterator it;
    for(it=tdls.begin();it!=tdls.end();++it) p.add_node_todel(*it);}
  }

  void plotters(std::vector<plotter*>& a_vec) { //a_vec do NOT get ownership of sg::plotter objects.
    a_vec.clear();
    if(m_sep.empty()) update_sg();
    size_t _number = m_sep.size();    
    for(size_t index=0;index<_number;index++) {
      reg_t* sep = (reg_t*)m_sep[index];
      plotter* _plotter = (plotter*)(*sep)[PLOTTER()];
      a_vec.push_back(_plotter);
    }    
  }

public:
  void init_sg() {
    m_group.clear();
    m_sep.clear();
    m_border_sep.clear();
    m_group.add(new noderef(m_sep)); 
    m_group.add(new noderef(m_border_sep)); 
  }
protected:
  typedef separator reg_t;
  void update_sg(){

    if(m_sep.empty()||(cols.value()!=m_old_cols)||(rows.value()!=m_old_rows)){

      m_old_cols = cols;
      m_old_rows = rows;

      m_sep.clear();

      unsigned int index = 0;
      for(unsigned int irow=0;irow<rows;irow++) {
        for(unsigned int icol=0;icol<cols;icol++) {
          reg_t* sep = new reg_t;
          m_sep.add(sep);

          sep->add(new sg::matrix); //MATRIX()

          head_light* light = new head_light;
          light->direction = vec3f(1,-1,-10);
          light->on = false;
          sep->add(light); //LIGHT()

          _switch* border = new _switch;
          sep->add(border); //BORDER()

          //matrix* tsf = new matrix;
          //sep->add(tsf); //TSF()

          sep->add(new plotter(m_ttf)); //PLOTTER()

          index++;
        } 
      } 

      if(m_current>=m_sep.size()) m_current = 0;
    }

    update_current_border();
    update_border();

    if((width.value()>0)&&(height.value()>0)) {

      // all window wc :
      float ww_wc = width;
      float wh_wc = height;
  
      // region size in window wc :
      float rw_wc = ww_wc/cols;
      float rh_wc = wh_wc/rows;
  
      size_t _number = m_sep.size();    
      for(size_t index=0;index<_number;index++) {
        size_t row = index/cols.value();
        size_t col = index-cols.value()*row;
  
        reg_t* sep = (reg_t*)m_sep[index];
  
        matrix* _matrix = (matrix*)(*sep)[MATRIX()];
        float x = -ww_wc*0.5f + col * rw_wc + rw_wc * 0.5f;
        float y =  wh_wc*0.5f - row * rh_wc - rh_wc * 0.5f;
        _matrix->set_translate(x,y,0);
        _matrix->mul_scale(plotter_scale.value(),plotter_scale.value(),1); //applied first.
  
       {_switch* _border = (_switch*)(*sep)[BORDER()];
        create_plotter_border(*_border,rw_wc,rh_wc);
        _border->which = view_border.value()?(index==m_current?0:1):1;}
        
        plotter* _plotter = (plotter*)(*sep)[PLOTTER()];
        
        if(_plotter->shape.value()==plotter::xy) {
          _plotter->width = rw_wc;
          _plotter->height = rh_wc;
          _plotter->depth = tools::mn(rw_wc,rh_wc);
        } else {
          if((rw_wc/rh_wc)>=1.0f) {
            _plotter->width = rh_wc;
            _plotter->height = rh_wc;
            _plotter->depth = rh_wc;
          } else {
            _plotter->width = rw_wc;
            _plotter->height = rw_wc;
            _plotter->depth = rh_wc;
          }
        }
  
      }    

    }    
  }  

  void create_plotter_border(_switch& a_parent,float a_w,float a_h) {
    a_parent.clear();

    group* sep = new group;
    a_parent.add(sep);

    a_parent.add(new group()); //empty

    rgba* mat = new rgba();
    mat->color = colorf_red();
    sep->add(mat);

    draw_style* ds = new draw_style;
    ds->style = draw_style::lines;
    ds->line_width = 4;
    sep->add(ds);

    vertices* vtxs = new vertices;
    vtxs->mode = gl::line_strip();
    sep->add(vtxs);

    float dw = a_w*0.5f;
    float dh = a_h*0.5f;
    vtxs->add(-dw,-dh,0);
    vtxs->add( dw,-dh,0);
    vtxs->add( dw, dh,0);
    vtxs->add(-dw, dh,0);
    vtxs->add(-dw,-dh,0);
  }

  void update_current_border() {
    size_t _number = m_sep.size();    
    for(size_t index=0;index<_number;index++) {
      reg_t* sep = (reg_t*)m_sep[index];
      _switch* _border = (_switch*)(*sep)[BORDER()];
      if(index==m_current) {  
        _border->which = view_border.value()?0:1;
        if(m_updater) m_updater->update(*this,index);
      } else {
        _border->which = 1;
      }
    }    
  }  

  void update_border() {
    m_border_sep.clear();

    if(!border_visible.value()) return;

    if(width.value()<=0) return;
    if(height.value()<=0) return;
    if(border_width.value()<=0) return;
    if(border_height.value()<=0) return;

    float bw = border_width;
    float bh = border_height;

    // do it with four externals back_area.

    float zz = 0;

    // top :
   {separator* sep = new separator;
    m_border_sep.add(sep);

    float wba = width+2*bw;
    float hba = bh;
    float x = 0;
    float y = height*0.5f+bh*0.5f;

    matrix* _m = new matrix;
    _m->set_translate(x,y,zz);
    sep->add(_m);

    back_area* b = new back_area;
    b->border_visible = false;
    b->color = border_color;      
    b->width = wba;
    b->height = hba;
    sep->add(b);}

    // bottom :
   {separator* sep = new separator;
    m_border_sep.add(sep);

    float wba = width+2*bw;
    float hba = bh;
    float x = 0;
    float y = -height*0.5f-bh*0.5f;

    matrix* _m = new matrix;
    _m->set_translate(x,y,zz);
    sep->add(_m);

    back_area* b = new back_area;
    b->border_visible = false;
    b->color = border_color;      
    b->width = wba;
    b->height = hba;
    sep->add(b);}

    // left :
   {separator* sep = new separator;
    m_border_sep.add(sep);

    float wba = bw;
    float hba = height+2*bh;
    float x = -width*0.5f-bw*0.5f;
    float y = 0;

    matrix* _m = new matrix;
    _m->set_translate(x,y,zz);
    sep->add(_m);

    back_area* b = new back_area;
    b->border_visible = false;
    b->color = border_color;      
    b->width = wba;
    b->height = hba;
    sep->add(b);}

    // right :
   {separator* sep = new separator;
    m_border_sep.add(sep);

    float wba = bw;
    float hba = height+2*bh;
    float x = width*0.5f+bw*0.5f;
    float y = 0;

    matrix* _m = new matrix;
    _m->set_translate(x,y,zz);
    sep->add(_m);

    back_area* b = new back_area;
    b->border_visible = false;
    b->color = border_color;      
    b->width = wba;
    b->height = hba;
    sep->add(b);}

  }
    
protected:
  const base_freetype& m_ttf;

  group m_group;
  separator m_sep;
  separator m_border_sep;
  unsigned int m_current;
  updater* m_updater;
  unsigned int m_old_cols;
  unsigned int m_old_rows;
};

}}

#endif