#ifndef SHADER_H
#define SHADER_H

#include <sstream>

#include "opengl.h"
#include "util.h"

namespace shader {

  using namespace std;

  const int NAMELEN = 32;

  template<class T>
  struct sl_expr {
    const T t;
    sl_expr (const T &t) : t(t) { }
    void operator ()() const { t (); }
  };

  template<class A, class B>
  struct sl_concat2
  {
    const A a; const B b;
    sl_concat2 (const A &a, const B &b) : a(a), b(b) { }
    void operator ()() const { a (); b (); }
  };

  template<class A, class B, class C>
  struct sl_concat3
  {
    const A a; const B b; const C c;
    sl_concat3 (const A &a, const B &b, const C &c) : a(a), b(b), c(c) { }
    void operator ()() const { a (); b (); c (); }
  };

  template<class A, class B, class C, class D>
  struct sl_concat4
  {
    const A a; const B b; const C c; const D d;
    sl_concat4 (const A &a, const B &b, const C &c, const D &d) : a(a), b(b), c(c), d(d) { }
    void operator ()() const { a (); b (); c (); d(); }
  };

  class refcounted
  {
    template<class type> friend class ref;
    mutable int refcnt;
    void refcnt_inc () const { refcnt++; }
    void refcnt_dec () const { if (!--refcnt) delete this; };
  public:
    refcounted () : refcnt(0) { }
    virtual ~refcounted ();
  };

  template<class type>
  struct ref
  {
    type *p;

    ref ()
    {
      p = new type;
      p->refcnt_inc ();
    }

    ref (type &d)
    {
      d.refcnt_inc ();
      p = &d;
    }

    ref (const ref &r)
    {
      r.p->refcnt_inc ();
      p = r.p;
    }

    template<class type2>
    ref (const ref<type2> &r)
    {
      r.p->refcnt_inc ();
      p = r.p;
    }

    ~ref ()
    {
      p->refcnt_dec ();
    }

    ref &operator =(type &d)
    {
      d.refcnt_inc ();
      p->refcnt_dec ();
      p = &d;
      return *this;
    }

    type *operator ->() const { return p; }

    operator type &() const { return *p; }

    template<class type2>
    bool operator ==(const ref<type2> b) const
    {
      return (void *)p == (void *)b.p;
    }
  };
  
  // ref with auto-construct
  template<class type>
  struct auto_ref0 : ref<type>
  {
    auto_ref0 () : ref<type> (*new type ()) { }
  };

  template<class type, typename arg1>
  struct auto_ref1 : ref<type>
  {
    auto_ref1 (arg1 a) : ref<type> (*new type (a)) { }
  };

  template<class type>
  struct auto_lvalue_ref0 : ref<type>
  {
    auto_lvalue_ref0 () : ref<type> (*new type ()) { }
    template<typename expr>
    const auto_lvalue_ref0 &operator =(const expr &e) const;
  };

  template<class type, typename arg1>
  struct auto_lvalue_ref1 : ref<type>
  {
    auto_lvalue_ref1 (arg1 a) : ref<type> (*new type (a)) { }
    template<class expr>
    const auto_lvalue_ref1 &operator =(const expr &e) const;
  };

  extern const char str_float [];
  extern const char str_vec2  [];
  extern const char str_vec3  [];
  extern const char str_vec4  [];
  extern const char str_mat2  [];
  extern const char str_mat3  [];
  extern const char str_mat4  [];

  extern const char str_sampler_1d             [];
  extern const char str_sampler_1d_shadow      [];
  extern const char str_sampler_2d             [];
  extern const char str_sampler_2d_shadow      [];
  extern const char str_sampler_2d_rect        [];
  extern const char str_sampler_2d_rect_shadow [];
  extern const char str_sampler_3d             [];
  extern const char str_sampler_3d_rect        [];
  extern const char str_sampler_cube           [];

  typedef ref<struct var_i> var;
  typedef ref<struct uniform_i> uniform;

  struct shader_builder
  {
    vector<uniform> refs; // uniform parameters
    vector<var> temps; // temporary variables
    vector<var> streams; // varying inputs & outputs

    ostringstream source;

    template<typename type>
    shader_builder &operator <<(const type &t)
    {
      source << t;
      return *this;
    }
  };

  struct fragment_i : refcounted
  {
    virtual void build (shader_builder &b) = 0;
  };

  typedef ref<fragment_i> fragment;

  struct lvalue_i : fragment_i
  {
  };

  // a simple predeclared variable with unspecified type
  struct glvar_i : lvalue_i
  {
    const char *name;
    void build (shader_builder &b);
    glvar_i (const char *name) : name (name) { }
  };

  typedef auto_lvalue_ref1<glvar_i, const char *> glvar;

  struct var_i : lvalue_i
  {
    static unsigned int next_id;

    char name[NAMELEN];
    const char *typestr;

    void build (shader_builder &b);
    virtual void build_decl (ostringstream &b);

    var_i (const char *typestr);
    ~var_i ();
  };

  struct uniform_i : var_i
  {
    bool dirty;

    virtual void update () = 0;

    void build (shader_builder &b);
    void build_decl (ostringstream &b);
    uniform_i (const char *strtype);
  };

  template<int dimension, typename gltype, const char *strtype, void (*upd)(CGparameter, const gltype *)>
  struct uniform2_i : uniform_i
  {
    gltype data[dimension];

    void update ()
    {
      if (dirty)
        {
          //upd (param, data);
          dirty = false;
        }
    }

    uniform2_i () : uniform_i (strtype) { }
  };

  template<int dimension, const char *strtype, void (*update)(CGparameter, const GLfloat *)>
  struct uniform_f_i : uniform2_i<dimension, GLfloat, strtype, update>
  {
  };

  struct uniform_1f_i : uniform_f_i<1, str_float, cgGLSetParameter1fv> {
    void operator =(GLfloat v)
    {
      data[0] = v;
      dirty = true;
    }
  };

  struct uniform_2f_i : uniform_f_i<2, str_vec2, cgGLSetParameter2fv> { };

  struct uniform_3f_i : uniform_f_i<3, str_vec3, cgGLSetParameter3fv> {
    void operator =(const vec3 &v)
    {
      data[0] = v.x;
      data[1] = v.y;
      data[2] = v.z;
      dirty = true;
    }
  };

  struct uniform_4f_i : uniform_f_i<4, str_vec4, cgGLSetParameter4fv> {
#if 0
    void operator =(const gl::matrix &m)
    {
      memcpy (data, m.data, 16 * sizeof (GLfloat));
      dirty = true;
    }
#endif
  };

  struct uniform_matrix_2f_i : uniform_f_i< 4, str_mat2, cgGLSetMatrixParameterfc> { };
  struct uniform_matrix_3f_i : uniform_f_i< 9, str_mat3, cgGLSetMatrixParameterfc> { };
  struct uniform_matrix_4f_i : uniform_f_i<16, str_mat4, cgGLSetMatrixParameterfc> { };

  template<class var_i>
  struct var_ref : ref<var_i>
  {
    var_ref (const char *glname = 0)
    : ref<var_i> (*new var_i)
    {
      if (glname)
        strcpy ((*this)->name, glname);
    }
  };

  typedef var_ref<uniform_1f_i> uniform_1f;
  typedef var_ref<uniform_2f_i> uniform_2f;
  typedef var_ref<uniform_3f_i> uniform_3f;
  typedef var_ref<uniform_4f_i> uniform_4f;
  typedef var_ref<uniform_matrix_2f_i> uniform_matrix_2f;
  typedef var_ref<uniform_matrix_3f_i> uniform_matrix_3f;
  typedef var_ref<uniform_matrix_4f_i> uniform_matrix_4f;

  struct stream_i : var_i
  {
    void build (shader_builder &b);
    void build_decl (ostringstream &b);
    stream_i (const char *strtype) : var_i (strtype) { }
  };

  template<int dimension, GLenum gltype, const char *strtype>
  struct varying_i : stream_i
  {
    varying_i (const char *glname)
    : stream_i (strtype)
    {
      strcpy (name, glname);
    }

    void set (GLsizei stride, GLvoid *ptr)
    {
      //cgGLSetParameterPointer (param, dimension, gltype, stride, ptr);
    }
  };

  template<int dimension, const char *strtype>
  struct varying_f_i : varying_i<dimension, GL_FLOAT, strtype>
  {
    varying_f_i (const char *glname) : varying_i<dimension, GL_FLOAT, strtype> (glname) { }

    void set (const gl::vertex_buffer_object &vb, GLint offset)
    {
      varying_i<dimension, GL_FLOAT, strtype>::set (gl::format_stride (vb.format), (GLvoid *)(long)offset);
    }
  };

  struct varying_1f_i : varying_f_i<1, str_float>
  {
    varying_1f_i (const char *glname) : varying_f_i<1, str_float> (glname) { }
  };

  struct varying_2f_i : varying_f_i<2, str_vec2>
  {
    varying_2f_i (const char *glname) : varying_f_i<2, str_vec2> (glname) { }

    void set_t (const gl::vertex_buffer_object &vb)
    {
      set (vb, gl::format_offset_t (vb.format));
    }
  };

  struct varying_3f_i : varying_f_i<3, str_vec3>
  {
    varying_3f_i (const char *glname) : varying_f_i<3, str_vec3> (glname) { }

    void set_p (const gl::vertex_buffer_object &vb)
    {
      set (vb, gl::format_offset_p (vb.format));
    }

    void set_n (const gl::vertex_buffer_object &vb)
    {
      set (vb, gl::format_offset_n (vb.format));
    }
  };

  struct varying_4f_i : varying_f_i<4, str_vec4>
  {
    varying_4f_i (const char *glname) : varying_f_i<4, str_vec4> (glname) { }
  };

  typedef var_ref<varying_1f_i> varying_1f;
  typedef var_ref<varying_2f_i> varying_2f;
  typedef var_ref<varying_3f_i> varying_3f;
  typedef var_ref<varying_4f_i> varying_4f;

  struct temporary_i : var_i
  {
    void build (shader_builder &b);

    temporary_i (const char *strtype);
  };

  template<const char *strtype>
  struct temp_ref : ref<temporary_i>
  {
    temp_ref ()
    : ref<temporary_i> (*new temporary_i (strtype))
    {
    }

    template<typename expr>
    const temp_ref &operator =(const expr &e) const;
  };

  typedef temp_ref<str_float> temp_1f;
  typedef temp_ref<str_vec2>  temp_2f;
  typedef temp_ref<str_vec3>  temp_3f;
  typedef temp_ref<str_vec4>  temp_4f;
  typedef temp_ref<str_mat2>  temp_matrix_2f;
  typedef temp_ref<str_mat3>  temp_matrix_3f;
  typedef temp_ref<str_mat4>  temp_matrix_4f;

  template<GLenum gltype, const char *strtype>
  struct sampler_i : uniform_i
  {
    GLuint texture;

    void update ()
    {
      if (dirty)
        {
          //cgGLSetTextureParameter (param, texture);
          dirty = false;
        }
    }

    void begin ()
    {
      cgGLEnableTextureParameter (texture);
    }

    sampler_i (GLuint texturename) : uniform_i (strtype), texture (texturename) { }
  };

  struct sampler_1d_i : sampler_i<CG_SAMPLER1D, str_sampler_1d>
  {
    sampler_1d_i (GLuint texturename) : sampler_i<CG_SAMPLER1D, str_sampler_1d> (texturename) { }
  };

  struct sampler_1d_shadow_i : sampler_i<CG_SAMPLER1D, str_sampler_1d_shadow>
  {
    sampler_1d_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLER1D, str_sampler_1d_shadow> (texturename) { }
  };

  struct sampler_2d_i : sampler_i<CG_SAMPLER2D, str_sampler_2d>
  {
    sampler_2d_i (GLuint texturename) : sampler_i<CG_SAMPLER2D, str_sampler_2d> (texturename) { }
  };

  struct sampler_2d_shadow_i : sampler_i<CG_SAMPLER2D, str_sampler_2d_shadow>
  {
    sampler_2d_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLER2D, str_sampler_2d_shadow> (texturename) { }
  };

  struct sampler_2d_rect_i : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect>
  {
    sampler_2d_rect_i (GLuint texturename) : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect> (texturename) { }
  };

  struct sampler_2d_rect_shadow_i : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect_shadow>
  {
    sampler_2d_rect_shadow_i (GLuint texturename) : sampler_i<CG_SAMPLERRECT, str_sampler_2d_rect_shadow> (texturename) { }
  };

  struct sampler_3d_i : sampler_i<CG_SAMPLER3D, str_sampler_3d>
  {
    sampler_3d_i (GLuint texturename) : sampler_i<CG_SAMPLER3D, str_sampler_3d> (texturename) { }
  };

  struct sampler_3d_rect_i : sampler_i<CG_SAMPLER3D, str_sampler_3d_rect>
  {
    sampler_3d_rect_i (GLuint texturename) : sampler_i<CG_SAMPLER3D, str_sampler_3d_rect> (texturename) { }
  };

  struct sampler_cube_i : sampler_i<CG_SAMPLERCUBE, str_sampler_cube>
  {
    sampler_cube_i (GLuint texturename) : sampler_i<CG_SAMPLERCUBE, str_sampler_cube> (texturename) { }
  };

  typedef auto_ref1<sampler_1d_i, GLuint>             sampler_1d;
  typedef auto_ref1<sampler_1d_shadow_i, GLuint>      sampler_1d_shadow;
  typedef auto_ref1<sampler_2d_i, GLuint>             sampler_2d;
  typedef auto_ref1<sampler_2d_shadow_i, GLuint>      sampler_2d_shadow;
  typedef auto_ref1<sampler_2d_rect_i, GLuint>        sampler_2d_rect;
  typedef auto_ref1<sampler_2d_rect_shadow_i, GLuint> sampler_2d_rect_shadow;
  typedef auto_ref1<sampler_3d_i, GLuint>             sampler_3d;
  typedef auto_ref1<sampler_3d_rect_i, GLuint>        sampler_3d_rect;
  typedef auto_ref1<sampler_cube_i, GLuint>           sampler_cube;

  struct fragment_const_string_i : fragment_i
  {
    const char *str;

    void build (shader_builder &b);

    fragment_const_string_i (const char *str) : str(str) { }
  };

  typedef auto_ref1<fragment_const_string_i, const char *> fragment_const_string;

  struct fragment_string_i : fragment_i
  {
    char *str;

    void build (shader_builder &b);

    fragment_string_i (const char *str) : str (strdup (str)) { }
    ~fragment_string_i ();
  };

  struct fragment_vector_i : fragment_i, vector<fragment>
  {
    void build (shader_builder &b);

    template<class fragment_i>
    void append (const ref<fragment_i> &f)
    {
      push_back (f);
    }

    void append_const (const char *s)
    {
      push_back (*new fragment_const_string_i (s));
    }

    void append_string (const char *s)
    {
      push_back (*new fragment_string_i (s));
    }

#if 0
    fragment_vector_i &operator <<(statement_i &f)
    {
      push_back (*new fragment_const_string_i ("  "));

      for (vector<fragment>::iterator i = f.begin (); i != f.end (); i++)
        push_back (*i);

      push_back (*new fragment_const_string_i (";\n"));
      return *this;
    }
#endif
  };

  typedef ref<fragment_vector_i> fragment_vector;

  struct shader_object_i : fragment_vector_i
  {
    GLenum type;
    GLuint id; // GLhandleARB, but 2.0 will use uint

    string source ();
    void compile ();
    void start ();
    void stop ();

    shader_object_i (GLenum type);
    ~shader_object_i ();
  };

  extern shader_object_i *cur; // record actions to this shader

  template<GLenum type>
  struct shader_object : ref<shader_object_i>
  {
    shader_object ()
    : ref<shader_object_i> (*new shader_object_i (type))
    {
    }
  };

  typedef shader_object<GL_VERTEX_SHADER_ARB>   vertex_shader;
  typedef shader_object<GL_FRAGMENT_SHADER_ARB> fragment_shader;

  void debdebdebdebug ();//D
}

#endif