#include "Core_Global.h"
#include "Frustum.h"
#include "Barrier.h"

cBarrier::cBarrier()
{
  m_NumBarriers = 0;
  m_BarrierParent = NULL;
}

cBarrier::~cBarrier()
{
  Free();
}

long cBarrier::GetNextLong(FILE *fp)
{
  char Buf[1024];
  long Pos = 0;
  int c;

  // Read until EOF or EOL
  while(1) {
    if((c = fgetc(fp)) == EOF)
      break;
    if(c == 0x0a || (c == ' ' && Pos))
      break;
    if((c >= '0' && c <= '9') || c == '.' || c == '-')
      Buf[Pos++] = c;
  }
  if(!Pos)
    return -1;
  Buf[Pos] = 0;

  return atol(Buf);
}

float cBarrier::GetNextFloat(FILE *fp)
{
  char Buf[1024];
  long Pos = 0;
  int c;

  // Read until EOF or EOL
  while(1) {
    if((c = fgetc(fp)) == EOF)
      break;
    if(c == 0x0a || (c == ' ' && Pos))
      break;
    if((c >= '0' && c <= '9') || c == '.' || c == '-')
      Buf[Pos++] = c;
  }
  Buf[Pos] = 0;

  return (float)atof(Buf);
}

BOOL cBarrier::SetMesh(long ID,                               \
                       cGraphics *Graphics, cMesh *Mesh)
{
  sBarrier *BarrierPtr;
  long Count = 0;

  // Loop through all Barriers looking for ID
  if((BarrierPtr = m_BarrierParent) != NULL) {
    while(BarrierPtr != NULL) {

      // If matched ID then set mesh
      if(BarrierPtr->ID == ID) {
        BarrierPtr->Object.Create(Graphics, Mesh);
        Count++;
      }

      // Go to next flag
      BarrierPtr = BarrierPtr->Next;
    }
  }

  // Return TRUE if any meshes set
  return (Count) ? TRUE : FALSE;
}

BOOL cBarrier::SetAnim(long ID, cAnimation *Anim,             \
                       char *Name, long Time)
{
  sBarrier *BarrierPtr;
  long Count = 0;

  // Loop through all Barriers looking for ID
  if((BarrierPtr = m_BarrierParent) != NULL) {
    while(BarrierPtr != NULL) {

      // If matched ID then set animation
      if(BarrierPtr->ID == ID) {
        BarrierPtr->Object.SetAnimation(Anim, Name, Time);
        Count++;
      }

      // Go to next flag
      BarrierPtr = BarrierPtr->Next;
    }
  }

  // Return TRUE if any animations set
  return (Count) ? TRUE : FALSE;
}

BOOL cBarrier::Render(unsigned long Time, cFrustum *Frustum)
{
  sBarrier *BarrierPtr;
  float Radius;

  // Error checking
  if(Frustum == NULL)
    return FALSE;

  // Loop through all Barriers looking for ID
  if((BarrierPtr = m_BarrierParent) != NULL) {
    while(BarrierPtr != NULL) {

      // Get radius and perform frustum check
      BarrierPtr->Object.GetBounds(NULL,NULL,NULL,NULL,       \
                                   NULL,NULL,&Radius);
      if(Frustum->CheckSphere(BarrierPtr->XPos,               \
                              BarrierPtr->YPos,               \
                              BarrierPtr->ZPos, Radius)) {

        // Position object
        BarrierPtr->Object.Move(BarrierPtr->XPos,             \
                                BarrierPtr->YPos,             \
                                BarrierPtr->ZPos);
        BarrierPtr->Object.Rotate(BarrierPtr->XRot,           \
                                  BarrierPtr->YRot,           \
                                  BarrierPtr->ZRot);

        // Update animation
        BarrierPtr->Object.UpdateAnimation(Time, TRUE);

        // Render object
        BarrierPtr->Object.Render();
      }

      // Go to next flag
      BarrierPtr = BarrierPtr->Next;
    }
  }

  return TRUE;
}

BOOL cBarrier::Load(char *Filename)
{
  FILE *fp;
  long Type, ID;
  BOOL Enabled;
  float x1, y1, z1, x2, y2, z2, x3, z3, Radius;
  float XPos, YPos, ZPos, XRot, YRot, ZRot;
  
  // Remove all current Barriers
  Free();

  // Open file
  if((fp=fopen(Filename, "rb"))==NULL)
    return FALSE;

  // Start looping, reading in until EOF reached
  while(1) {
    // Get ID of Barrier
    if((ID = GetNextLong(fp)) == -1)
      break;

    // Get type
    Type = GetNextLong(fp);

    // Get enabled status
    Enabled = (GetNextLong(fp)) ? TRUE : FALSE;

    // Get coordinates and rotation
    XPos = GetNextFloat(fp);
    YPos = GetNextFloat(fp);
    ZPos = GetNextFloat(fp);
    XRot = GetNextFloat(fp);
    YRot = GetNextFloat(fp);
    ZRot = GetNextFloat(fp);

    // Read in rest depending on type
    switch(Type) {
      case Barrier_Sphere:
        x1 = GetNextFloat(fp);
        y1 = GetNextFloat(fp);
        z1 = GetNextFloat(fp);
        Radius = GetNextFloat(fp);
        AddSphere(ID, Enabled, XPos, YPos, ZPos,              \
                  XRot, YRot, ZRot, x1, y1, z1, Radius);
        break;
      
      case Barrier_Box:
        x1 = GetNextFloat(fp);
        y1 = GetNextFloat(fp);
        z1 = GetNextFloat(fp);
        x2 = GetNextFloat(fp);
        y2 = GetNextFloat(fp);
        z2 = GetNextFloat(fp);
        AddBox(ID, Enabled, XPos, YPos, ZPos,                 \
               XRot, YRot, ZRot, x1, y1, z1, x2, y2, z2);
        break;
      
      case Barrier_Cylinder:
        x1 = GetNextFloat(fp);
        y1 = GetNextFloat(fp);
        z1 = GetNextFloat(fp);
        Radius = GetNextFloat(fp);
        y2 = GetNextFloat(fp);
        AddCylinder(ID, Enabled, XPos, YPos, ZPos,            \
                    XRot, YRot, ZRot, x1, y1, z1, Radius, y2);
        break;
      
      case Barrier_Triangle:
        x1 = GetNextFloat(fp);
        z1 = GetNextFloat(fp);
        x2 = GetNextFloat(fp);
        z2 = GetNextFloat(fp);
        x3 = GetNextFloat(fp);
        z3 = GetNextFloat(fp);
        y1 = GetNextFloat(fp);
        y2 = GetNextFloat(fp);
        AddTriangle(ID, Enabled, XPos, YPos, ZPos,            \
                    XRot, YRot, ZRot,                         \
                    x1, z1, x2, z2, x3, z3, y1, y2);
        break;

      default: fclose(fp);    // Some error occurred
               Free();
               return FALSE;
    }
  }

  fclose(fp);

  return (m_NumBarriers) ? TRUE : FALSE;
}

BOOL cBarrier::Save(char *Filename)
{
  FILE *fp;
  sBarrier *BarrierPtr;

  if(!m_NumBarriers)
    return FALSE;
  if((BarrierPtr = m_BarrierParent) == NULL)
    return FALSE;
  
  // Open file
  if((fp=fopen(Filename, "wb"))==NULL)
    return FALSE;

  // Write out all Barriers
  while(BarrierPtr != NULL) {
    // Write out ID and Type of Barrier
    fprintf(fp, "%lu ", BarrierPtr->ID);
    fprintf(fp, "%lu ", BarrierPtr->Type);

    // Write out Enabled flag
    fprintf(fp, "%lu ", (BarrierPtr->Enabled) ? 1 : 0);

    // Write out coordinates and rotation
    fprintf(fp, "%lf %lf %lf %lf %lf %lf ",                   \
      BarrierPtr->XPos, BarrierPtr->YPos, BarrierPtr->ZPos,   \
      BarrierPtr->XRot, BarrierPtr->YRot, BarrierPtr->ZRot);

    // Write out remaining data depending on type
    switch(BarrierPtr->Type) {
      case Barrier_Sphere:
        fprintf(fp, "%lf %lf %lf %lf\r\n",                    \
                BarrierPtr->x1, BarrierPtr->y1,               \
                BarrierPtr->z1, BarrierPtr->Radius);
        break;
      
      case Barrier_Box:
        fprintf(fp, "%lf %lf %lf %lf %lf %lf\r\n",            \
           BarrierPtr->x1, BarrierPtr->y1, BarrierPtr->z1,    \
           BarrierPtr->x2, BarrierPtr->y2, BarrierPtr->z2);
        break;
      
      case Barrier_Cylinder:
        fprintf(fp, "%lf %lf %lf %lf %lf\r\n",                \
            BarrierPtr->x1, BarrierPtr->y1, BarrierPtr->z1,   \
            BarrierPtr->Radius, BarrierPtr->y2);
        break;
      
      case Barrier_Triangle:
        fprintf(fp, "%lf %lf %lf %lf %lf %lf %lf %lf\r\n",    \
                BarrierPtr->x1, BarrierPtr->z1,               \
                BarrierPtr->x2, BarrierPtr->z2,               \
                BarrierPtr->x3, BarrierPtr->z3,               \
                BarrierPtr->y1, BarrierPtr->y2);
        break;
    }
  }

  fclose(fp);

  return TRUE;
}

sBarrier *cBarrier::AddBarrier(long Type, long ID,            \
                        BOOL Enabled,                         \
                        float XPos, float YPos, float ZPos,   \
                        float XRot, float YRot, float ZRot)
{
  // Allocate a new Barrier structure and link in
  sBarrier *Barrier = new sBarrier();