/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.

This file is part of GtkRadiant.

GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#if !defined(INCLUDED_MODEL_H)
#define INCLUDED_MODEL_H

#include "cullable.h"
#include "renderable.h"
#include "selectable.h"
#include "modelskin.h"

#include "math/frustum.h"
#include "string/string.h"
#include "generic/static.h"
#include "stream/stringstream.h"
#include "os/path.h"
#include "scenelib.h"
#include "instancelib.h"
#include "transformlib.h"
#include "traverselib.h"
#include "render.h"

class VectorLightList : public LightList
{
  typedef std::vector<const RendererLight*> Lights;
  Lights m_lights;
public:
  void addLight(const RendererLight& light)
  {
    m_lights.push_back(&light);
  }
  void clear()
  {
    m_lights.clear();
  }
  void evaluateLights() const
  {
  }
  void lightsChanged() const
  {
  }
  void forEachLight(const RendererLightCallback& callback) const
  {
    for(Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i)
    {
      callback(*(*i));
    }
  }
};

inline VertexPointer vertexpointer_arbitrarymeshvertex(const ArbitraryMeshVertex* array)
{
  return VertexPointer(VertexPointer::pointer(&array->vertex), sizeof(ArbitraryMeshVertex));
}

inline void parseTextureName(CopiedString& name, const char* token)
{
  StringOutputStream cleaned(256);
  cleaned << PathCleaned(token);
  name = CopiedString(cleaned.c_str(), path_get_filename_base_end(cleaned.c_str())); // remove extension
}

// generic renderable triangle surface
class Surface : 
public OpenGLRenderable
{
public:
  typedef VertexBuffer<ArbitraryMeshVertex> vertices_t;
  typedef IndexBuffer indices_t;
private:

  AABB m_aabb_local;
  CopiedString m_shader;
  Shader* m_state;

  vertices_t m_vertices;
  indices_t m_indices;

  void CaptureShader()
  {
    m_state = GlobalShaderCache().capture(m_shader.c_str());
  }
  void ReleaseShader()
  {
    GlobalShaderCache().release(m_shader.c_str());
  }

public:

  Surface()
    : m_shader(""), m_state(0)
  {
    CaptureShader();
  }
  ~Surface()
  {
    ReleaseShader();
  }

  vertices_t& vertices()
  {
    return m_vertices;
  }
  indices_t& indices()
  {
    return m_indices;
  }

  void setShader(const char* name)
  {
    ReleaseShader();
    parseTextureName(m_shader, name);
    CaptureShader();
  }
  const char* getShader() const
  {
    return m_shader.c_str();
  }
  Shader* getState() const
  {
    return m_state;
  }
  void updateAABB()
  {
    m_aabb_local = AABB();
    for(vertices_t::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
      aabb_extend_by_point_safe(m_aabb_local, reinterpret_cast<const Vector3&>((*i).vertex));



    for(Surface::indices_t::iterator i = m_indices.begin(); i != m_indices.end(); i += 3)
    {
			ArbitraryMeshVertex& a = m_vertices[*(i + 0)];
			ArbitraryMeshVertex& b = m_vertices[*(i + 1)];
			ArbitraryMeshVertex& c = m_vertices[*(i + 2)];

      ArbitraryMeshTriangle_sumTangents(a, b, c);
    }

    for(Surface::vertices_t::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
    {
      vector3_normalise(reinterpret_cast<Vector3&>((*i).tangent));
      vector3_normalise(reinterpret_cast<Vector3&>((*i).bitangent));
    }
  }

  void render(RenderStateFlags state) const
  {
#if 1
    if((state & RENDER_BUMP) != 0)
    {
      if(GlobalShaderCache().useShaderLanguage())
      {
        glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
        glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
        glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
        glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->bitangent);
      }
      else
      {
        glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
        glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
        glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
        glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->bitangent);
      }
    }
    else
    {
      glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
      glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
    }
    glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->vertex);
    glDrawElements(GL_TRIANGLES, GLsizei(m_indices.size()), RenderIndexTypeID, m_indices.data());
#else
    glBegin(GL_TRIANGLES);
    for(unsigned int i = 0; i < m_indices.size(); ++i)
    {
      glTexCoord2fv(&m_vertices[m_indices[i]].texcoord.s);
      glNormal3fv(&m_vertices[m_indices[i]].normal.x);
      glVertex3fv(&m_vertices[m_indices[i]].vertex.x);
    }
    glEnd();
#endif

#if defined(_DEBUG)
    glBegin(GL_LINES);

    for(VertexBuffer<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
    {
      Vector3 normal = vector3_added(vertex3f_to_vector3((*i).vertex), vector3_scaled(normal3f_to_vector3((*i).normal), 8));
      glVertex3fv(vertex3f_to_array((*i).vertex));
      glVertex3fv(vector3_to_array(normal));
    }
    glEnd();
#endif
  }

  VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
  {
    return test.TestAABB(m_aabb_local, localToWorld);
  }

  const AABB& localAABB() const
  {
    return m_aabb_local;
  }

  void render(Renderer& renderer, const Matrix4& localToWorld, Shader* state) const
  {
    renderer.SetState(state, Renderer::eFullMaterials);
    renderer.addRenderable(*this, localToWorld);
  }

  void render(Renderer& renderer, const Matrix4& localToWorld) const
  {
    render(renderer, localToWorld, m_state);
  }

  void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
  {
    test.BeginMesh(localToWorld);

    SelectionIntersection best;
    test.TestTriangles(
      vertexpointer_arbitrarymeshvertex(m_vertices.data()),
      IndexPointer(m_indices.data(), IndexPointer::index_type(m_indices.size())),
      best
    );
    if(best.valid())
    {
      selector.addIntersection(best);
    }
  }
};

// generic model node
class Model :
public Cullable,
public Bounded
{
  typedef std::vector<Surface*> surfaces_t;
  surfaces_t m_surfaces;

  AABB m_aabb_local;
public:
  Callback m_lightsChanged;

  ~Model()
  {
    for(surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i)
    {
      delete *i;
    }
  }

  typedef surfaces_t::const_iterator const_iterator;

  const_iterator begin() const
  {
    return m_surfaces.begin();
  }
  const_iterator end() const
  {
    return m_surfaces.end();
  }
  std::size_t size() const
  {
    return m_surfaces.size();
  }

  Surface& newSurface()
  {
    m_surfaces.push_back(new Surface);
    return *m_surfaces.back();
  }
  void updateAABB()
  {
    m_aabb_local = AABB();
    for(surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i)
    {
      aabb_extend_by_aabb_safe(m_aabb_local, (*i)->localAABB());
    }
  }

  VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld) const
  {
    return test.TestAABB(m_aabb_local, localToWorld);
  }

  virtual const AABB& localAABB() const
  {
    return m_aabb_local;
  }

  void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld)
  {
    for(surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i)
    {
      if((*i)->intersectVolume(test.getVolume(), localToWorld) != c_volumeOutside)
      {
        (*i)->testSelect(selector, test, localToWorld);
      }
    }
  }
};

inline void Surface_addLight(const Surface& surface, VectorLightList& lights, const Matrix4& localToWorld, const RendererLight& light)
{
  if(light.testAABB(aabb_for_oriented_aabb(surface.localAABB(), localToWorld)))
  {
    lights.addLight(light);
  }
}

class ModelInstance :
  public scene::Instance,
  public Renderable,
  public SelectionTestable,
  public LightCullable,
  public SkinnedModel
{
  class TypeCasts
  {
    InstanceTypeCastTable m_casts;
  public:
    TypeCasts()
    {
      InstanceContainedCast<ModelInstance, Bounded>::install(m_casts);
      InstanceContainedCast<ModelInstance, Cullable>::install(m_casts);
      InstanceStaticCast<ModelInstance, Renderable>::install(m_casts);
      InstanceStaticCast<ModelInstance, SelectionTestable>::install(m_casts);
      InstanceStaticCast<ModelInstance, SkinnedModel>::install(m_casts);
    }
    InstanceTypeCastTable& get()
    {
      return m_casts;
    }
  };

  Model& m_model;

  const LightList* m_lightList;
  typedef Array<VectorLightList> SurfaceLightLists;
  SurfaceLightLists m_surfaceLightLists;

  class Remap
  {
  public:
    CopiedString first;
    Shader* second;
    Remap() : second(0)
    {
    }
  };
  typedef Array<Remap> SurfaceRemaps;
  SurfaceRemaps m_skins;
public:

  typedef LazyStatic<TypeCasts> StaticTypeCasts;

  Bounded& get(NullType<Bounded>)
  {
    return m_model;
  }
  Cullable& get(NullType<Cullable>)
  {
    return m_model;
  }

  void lightsChanged()
  {
    m_lightList->lightsChanged();
  }
  typedef MemberCaller<ModelInstance, &ModelInstance::lightsChanged> LightsChangedCaller;

  void constructRemaps()
  {
    ModelSkin* skin = NodeTypeCast<ModelSkin>::cast(path().parent());
    if(skin != 0 && skin->realised())
    {
      SurfaceRemaps::iterator j = m_skins.begin();
      for(Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i, ++j)
      {
        const char* remap = skin->getRemap((*i)->getShader());
        if(!string_empty(remap))
        {
          (*j).first = remap;
          (*j).second = GlobalShaderCache().capture(remap);
        }
        else
        {
          (*j).second = 0;
        }
      }
      SceneChangeNotify();
    }
  }
  void destroyRemaps()
  {
    for(SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i)
    {
      if((*i).second != 0)
      {
        GlobalShaderCache().release((*i).first.c_str());
        (*i).second = 0;
      }
    }
  }
  void skinChanged()
  {
    ASSERT_MESSAGE(m_skins.size() == m_model.size(), "ERROR");
    destroyRemaps();
    constructRemaps();
  }

  ModelInstance(const scene::Path& path, scene::Instance* parent, Model& model) :
    Instance(path, parent, this, StaticTypeCasts::instance().get()), 
    m_model(model),
    m_surfaceLightLists(m_model.size()),
    m_skins(m_model.size())
  {
    m_lightList = &GlobalShaderCache().attach(*this);
    m_model.m_lightsChanged = LightsChangedCaller(*this);

    Instance::setTransformChangedCallback(LightsChangedCaller(*this));

    constructRemaps();
  }
  ~ModelInstance()
  {
    destroyRemaps();

    Instance::setTransformChangedCallback(Callback());

    m_model.m_lightsChanged = Callback();
    GlobalShaderCache().detach(*this);
  }

  void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld) const
  {
    SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
    SurfaceRemaps::const_iterator k = m_skins.begin();
    for(Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i, ++j, ++k)
    {
      if((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside)
      {
        renderer.setLights(*j);
        (*i)->render(renderer, localToWorld, (*k).second != 0 ? (*k).second : (*i)->getState());
      }
    }
  }

  void renderSolid(Renderer& renderer, const VolumeTest& volume) const
  {
    m_lightList->evaluateLights();

    render(renderer, volume, Instance::localToWorld());
  }
  void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
  {
    renderSolid(renderer, volume);
  }

  void testSelect(Selector& selector, SelectionTest& test)
  {
    m_model.testSelect(selector, test, Instance::localToWorld());
  }

  bool testLight(const RendererLight& light) const
  {
    return light.testAABB(worldAABB());
  }
  void insertLight(const RendererLight& light)
  {
    const Matrix4& localToWorld = Instance::localToWorld();
    SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
    for(Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i)
    {
      Surface_addLight(*(*i), *j++, localToWorld, light);
    }
  }
  void clearLights()
  {
    for(SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i)
    {
      (*i).clear();
    }
  }
};

class ModelNode : public scene::Node::Symbiot, public scene::Instantiable
{
  class TypeCasts
  {
    NodeTypeCastTable m_casts;
  public:
    TypeCasts()
    {
      NodeStaticCast<ModelNode, scene::Instantiable>::install(m_casts);
    }
    NodeTypeCastTable& get()
    {
      return m_casts;
    }
  };


  scene::Node m_node;
  InstanceSet m_instances;
  Model m_model;
public:

  typedef LazyStatic<TypeCasts> StaticTypeCasts;

  ModelNode() : m_node(this, this, StaticTypeCasts::instance().get())
  {
  }

  Model& model()
  {
    return m_model;
  }

  void release()
  {
    delete this;
  }
  scene::Node& node()
  {
    return m_node;
  }

  scene::Instance* create(const scene::Path& path, scene::Instance* parent)
  {
    return new ModelInstance(path, parent, m_model);
  }
  void forEachInstance(const scene::Instantiable::Visitor& visitor)
  {
    m_instances.forEachInstance(visitor);
  }
  void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance)
  {
    m_instances.insert(observer, path, instance);
  }
  scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path)
  {
    return m_instances.erase(observer, path);
  }
};


inline void Surface_constructQuad(Surface& surface, const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d, const Vector3& normal)
{
  surface.vertices().push_back(
    ArbitraryMeshVertex(
      vertex3f_for_vector3(a),
      normal3f_for_vector3(normal),
      texcoord2f_from_array(aabb_texcoord_topleft)
    )
  );
  surface.vertices().push_back(
    ArbitraryMeshVertex(
      vertex3f_for_vector3(b),
      normal3f_for_vector3(normal),
      texcoord2f_from_array(aabb_texcoord_topright)
    )
  );
  surface.vertices().push_back(
    ArbitraryMeshVertex(
      vertex3f_for_vector3(c),
      normal3f_for_vector3(normal),
      texcoord2f_from_array(aabb_texcoord_botright)
    )
  );
  surface.vertices().push_back(
    ArbitraryMeshVertex(
      vertex3f_for_vector3(d),
      normal3f_for_vector3(normal),
      texcoord2f_from_array(aabb_texcoord_botleft)
    )
  );
}

inline void Model_constructNull(Model& model)
{
  Surface& surface = model.newSurface();

  AABB aabb(Vector3(0, 0, 0), Vector3(8, 8, 8));

  Vector3 points[8];
	aabb_corners(aabb, points);

  surface.vertices().reserve(24);

  Surface_constructQuad(surface, points[2], points[1], points[5], points[6], aabb_normals[0]);
  Surface_constructQuad(surface, points[1], points[0], points[4], points[5], aabb_normals[1]);
  Surface_constructQuad(surface, points[0], points[1], points[2], points[3], aabb_normals[2]);
  Surface_constructQuad(surface, points[0], points[3], points[7], points[4], aabb_normals[3]);
  Surface_constructQuad(surface, points[3], points[2], points[6], points[7], aabb_normals[4]);
  Surface_constructQuad(surface, points[7], points[6], points[5], points[4], aabb_normals[5]);

  surface.indices().reserve(36);

  RenderIndex indices[36] = {
     0,  1,  2,  0,  2,  3,
     4,  5,  6,  4,  6,  7,
     8,  9, 10,  8, 10, 11,
    12, 13, 14, 12, 14, 15,
    16, 17, 18, 16, 18, 19,
    20, 21, 22, 10, 22, 23,
  };

  for(RenderIndex* i = indices; i != indices+(sizeof(indices)/sizeof(RenderIndex)); ++i)
  {
    surface.indices().insert(*i);
  }

  surface.setShader("");

  surface.updateAABB();

  model.updateAABB();
}

#endif
