/**
*******************************************************************************

  @file /gui/model/hexy.cpp
  @brief Reprezentace hexu a proxyobjektu
  

  @author Pavel
  @version 0.1
 
******************************************************************************/

#include <GL/gl.h>
//
#include "gui/model/hexy.h"
#include "gui/model/guimap.h"
#include "gui/common/colors.h"

namespace gui{

/*TProxyObject***************************************************************************/
TProxyObject::TProxyObject(TguiMap* m, TProxyType t)
{
  hexWhereIam = NULL;
  map = m;
  type = t;
}

int TProxyObject::moveToHex(int newindex)
{
  if ( (newindex >= map->hexycount) || (newindex < 0) ) return 0;
  if (hexWhereIam != NULL) hexWhereIam->remProxy(this);
  map->hexy[newindex]->addProxy(this);
  return 1;
}

void TProxyObject::moveToHex(THex *newHex)
{
  if (hexWhereIam != NULL) hexWhereIam->remProxy(this);
  newHex->addProxy(this);
}

void TProxyObject::surfaceAltitude(float x, float y, float *z){
}









/*TBorderStone***************************************************************************/
TBorderStone::TBorderStone(THex* h, TModel* mod)
:TModelSceneObject(mod)
{
  hex = h;
}

void TBorderStone::drawObject()
{
  if(getRealFade()<2){
    float mat[] =  {ColorPlayer[ hex->owner ][0]/255.0f,
                    ColorPlayer[ hex->owner ][1]/255.0f,
                    ColorPlayer[ hex->owner ][2]/255.0f,
                    1};
    glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE, mat);
    //
    TModelSceneObject::drawObject();
  }
}









/*THex***********************************************************************************/
void THex::addProxy(TProxyObject* po)
{
  objs.push_back(po);
  po->hexWhereIam = this;
  po->addToHex(index);
}

TProxyObject *THex::remProxy(TProxyObject* po)
{
  Tproxyobjs::iterator it;
  it=objs.begin();
  while(it!=objs.end()){
    if(*it==po){
      objs.erase(it);
      po->hexWhereIam = NULL;
      return po;
    }
    it++;
  }
  return NULL;
}

TProxyObject* THex::getProxy(TProxyType t){
  Tproxyobjs::iterator it;
  it=objs.begin();
  while(it!=objs.end()){
    TProxyObject* o = (*it);
    if((*it)->type == t){
      return (*it);
    }
    it++;
  }
  return NULL;
}

void THex::getHexCenter(P3F* hc){
  int indx = getIndex();
  map->hexCentre(hc, indx);
}

void THex::altitudeCorection(float x, float y, float *z){
  float zz = -FLT_MAX;
  float zzz = *z;
  //
  for ( Tproxyobjs::iterator it = objs.begin();
        it!=objs.end();
        it++)
  {
    (*it)->surfaceAltitude(x, y, &zz);
    if(zz > zzz)
      zzz = zz;
  }
  //
  *z = zzz;
}

THex::THex(int ind, TModel* mod, TguiMap* m)
:TModelSceneObject(mod)
{
  model = mod;
  index = ind;
  map = m;
  watermodel = NULL;
  waterso = NULL;

  //
  highlightState = hhNoHighlight;
  dwDrawFlag |= DRAW_SHADOWRECEIVER;
}

THex::~THex()
{
  // zrus specialni model pro hex
  if (model != NULL) delete model;
  if (watermodel != NULL) delete watermodel;
  if (waterso != NULL) delete waterso;

  for(std::vector<TModelSceneObject*>::iterator it = borderstones.begin();
      it !=   borderstones.end();
      it++)
    delete (*it);

  //zrus proxyobjekty
  for(Tproxyobjs::iterator it2= objs.begin();it2!=objs.end();it2++) 
    delete (*it2);
    
  objs.clear();
}

void THex::createBorders(){
  
  //ziskej modrm
  rm::TRM_model_i*  mrm;
  if( !( mrm = (rm::TRM_model_i*)KSendBcAnMsg(MSG_GET_RM_MODEL_I, 0)) )
    THROW(E_8K_GUI, "TBuilding::initBuildings(): failed to query rmmodel interface\n");
  
  //ziskej model patniku
  TModel* mod = mrm->get(MODEL_BORDERSTONE);
  TBorderStone* bs = NULL;
  
  //projed hranice
  float ang = (float)M_PI;
  float dist = HEX_EDGE_LENGTH/(float)STONES_PER_EDGE;
  for(int i = 0; i < 6 ; i++){

    ang-=(float)M_PI/3;
    if( !(border_flag & (1<<i)) )continue;

    float x1 = (float)cos( ang )*BORDEREDGE_LENGTH;
    float y1 = (float)sin( ang )*BORDEREDGE_LENGTH;

    float x2 = (float)cos( ang-M_PI/3 )*BORDEREDGE_LENGTH;
    float y2 = (float)sin( ang-M_PI/3 )*BORDEREDGE_LENGTH;

    P3F pos;
    P2F dir;
    
    dir.x = (x2-x1)/(float)BORDEREDGE_LENGTH;
    dir.y = (y2-y1)/(float)BORDEREDGE_LENGTH;

    //a vytvor instance od (x1,y1)<->(x2,y2)
    for(int k = 0; k < STONES_PER_EDGE; k++){
  
      bs = new TBorderStone(this, mod);    
      bs->fade=0;
      
      //pozice
      map->hexCentre(&pos, index);
      pos.x += x1 + k*dist*dir.x;
      pos.y += y1 + k*dist*dir.y;
      map->altitude(pos.x, pos.y, &(pos.z));
      bs->setPosition(&pos);  
      
      //data
      borderstones.push_back( bs );      
      map->addObject( bs );
    }
  }
  
  //uvolni rm
  delete mrm;
}

void THex::preselect(){
  TModelSceneObject::preselect();
  highlightState |= hhHexHighlight;
  //
  map->hexPreselect_sensor(index);
}

void THex::preunselect(){
  TModelSceneObject::preunselect();
  highlightState &= ~hhHexHighlight;
  //
  map->hexPreselect_sensor(-1);
}

void THex::onClick(){
  map->hexClicked_sensor(index);
}

void THex::highlight(int on){
  //
  THighlighting::highlight(on);



  for(  std::vector<PMaterial>::iterator mit = model->matr.begin();
        mit != model->matr.end();
        mit++)
  {
    PMaterial matros = *mit;

    //osvetli plochu
    if(highlightState & hhHexAreaHighlight){

      //barva podle tagu
      if( hhtGetTag(highlightState) == 1 ){
        float d[] = {MOVE_HEX_HIGHLIGHT_COLOR, 1.0f};
        CopyV4(matros->diffuse.p, d);
      }
      else if( hhtGetTag(highlightState) == 2 ){
        float d[] = {ATTACK_HEX_HIGHLIGHT_COLOR, 1.0f};
        CopyV4(matros->diffuse.p, d);
      }
      else if( hhtGetTag(highlightState) == 3 ){
        float d[] = {BUILD_HEX_HIGHLIGHT_COLOR, 1.0f};
        CopyV4(matros->diffuse.p, d);
      }
    }
    //defaultni barva 
    else{
      float d[] = {1.0f, 1.0f, 1.0f, 1.0f};
      CopyV4(matros->diffuse.p, d);
    }
  }
}

void THex::drawHighlight(){
  //osvetli obvod
  if(highlightState & hhHexHighlight){
    glColor3f(HEX_PRESELECTION_COLOR);
    //
    map->drawCircle(aabbCenter.x, aabbCenter.y, HEX_EDGE_LENGTH-1, 6);
  }
}

void THex::drawLineBorders(){
  //nakresli hranice  
  glDisable(GL_LIGHTING);
  glLineWidth( 5 );
  glColor4f(ColorPlayer[owner][0]/255.0f,
            ColorPlayer[owner][1]/255.0f,
            ColorPlayer[owner][2]/255.0f, 0.3f);  
  float ang = (float)3*(float)M_PI/3;
  for(int i = 0; i < 6 ; i++){

    ang-=(float)M_PI/3;
    if( !(border_flag & (1<<i)) )continue;

    float x1 = (float)cos( ang )*(HEX_EDGE_LENGTH-3) + aabbCenter.x;
    float y1 = (float)sin( ang )*(HEX_EDGE_LENGTH-3) + aabbCenter.y;

    float x2 = (float)cos( ang-M_PI/3 )*(HEX_EDGE_LENGTH-3) + aabbCenter.x;
    float y2 = (float)sin( ang-M_PI/3 )*(HEX_EDGE_LENGTH-3) + aabbCenter.y;

    map->drawLine(x1, y1, x2, y2);
  }
  glLineWidth( 1 ); 
  glEnable(GL_LIGHTING);
}

void THex::drawObject()
{   
  //hranice
  //  if(fade<2)drawLineBorders();

  //HOT BUG FIX: na pocitacich v labu se restartuje, meni, 
  //prepisuje nastaveni GL_LIGHT_MODEL_AMBIENT, 
  //takze ho radsi natvrdo pokazdy nastavim
  float ff[] = {0.3f, 0.3f, 0.3f, 1.0f};
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ff);

  //hex
  TModelSceneObject::drawObject();  
 
  //osviceni
  drawHighlight();
}

int THex::getIndex(){
  return index;
}

void THex::setFade(int newfade)
{
  fade = newfade;
  if (waterso != NULL) waterso->fade = newfade;
  
  for(std::vector<TModelSceneObject*>::iterator it = borderstones.begin();
      it !=   borderstones.end();
      it++)
  {
    (*it)->fade = newfade;
  }  
}

}//namespace