#ifndef TYPEDEFS_H

#define TYPEDEFS_H

#include <iostream>
#include <iomanip>
#include <sstream>
#include <vector>
#include <limits>
#include <GL/glut.h>

using namespace std;

#undef max

typedef struct v3 //3d vector struct with overloaded operators
{
  double x,y,z;

  inline v3()                                 {x=y=z= 0.0;}
  inline v3(double vx, double vy, double vz)  { x=vx; y=vy; z=vz; }
  inline v3(const v3 &v)                      {x=v.x; y=v.y; z=v.z;}

  v3& operator=(const v3 &rhs) {x=rhs.x; y=rhs.y; z=rhs.z; return *this;}

  inline v3& operator+=(const v3 &rhs) {x+=rhs.x; y+=rhs.y; z+=rhs.z; return *this;}
  inline v3& operator-=(const v3 &rhs) {x-=rhs.x; y-=rhs.y; z-=rhs.z; return *this;}
  inline v3& operator*=(const v3 &rhs) {x*=rhs.x; y*=rhs.y; z*=rhs.z; return *this;}
  inline v3& operator/=(const v3 &rhs) {x/=rhs.x; y/=rhs.y; z/=rhs.z; return *this;}

  //scalar mult/div
  inline v3& operator*=(const double s) {x*=s; y*=s; z*=s; return *this;}
  inline v3& operator/=(const double s) {x/=s; y/=s; z/=s; return *this;}

  inline const v3 operator+(const v3 &rhs) const {v3 v(*this); return v+=rhs;} 
  inline const v3 operator-(const v3 &rhs) const {v3 v(*this); return v-=rhs;} 
  inline const v3 operator*(const v3 &rhs) const {v3 v(*this); return v*=rhs;}
  inline const v3 operator/(const v3 &rhs) const {v3 v(*this); return v/=rhs;}  

  inline const v3 operator*(const double s) const {v3 v(*this); return v*=s;}
  inline const v3 operator/(const double s) const {v3 v(*this); return v/=s;} 

  inline bool operator>(const v3 &rhs) const { return x>rhs.x && y>rhs.y && z>rhs.z; }
  inline bool operator<(const v3 &rhs) const { return x<rhs.x && y<rhs.y && z<rhs.z; }
} Vect3D_t;

//scalar vector multiplication s * v
inline const v3 operator*(const double s, const v3 &rhs) {return rhs*s;}

//output stream operator for Vect3D_t (handy for printing)
inline std::ostream& operator<<(std::ostream& os, const Vect3D_t& v ) 
{
  stringstream ss;
  ss << fixed << setprecision(2) << "(" << v.x << ", " << v.y << ", " << v.z << ")";

  return os << ss.str();
}

typedef struct bb
{
  Vect3D_t m_Min, //minimal corner vertex (-x, -y, -z)
           m_Max; //maximal corner vertex (+x, +y, +z)

  //default constructor creates a maximum inverted bounding box
  bb() 
  {
    //init a bounding box with the min values set to max double and visa versa
    double l_doubleMax = std::numeric_limits<double>::max();
    m_Min = Vect3D_t(l_doubleMax, l_doubleMax, l_doubleMax);
    m_Max = Vect3D_t(-l_doubleMax, -l_doubleMax, -l_doubleMax);
  }

  //copy constructor
  bb(const bb &b) : m_Min(b.m_Min), m_Max(b.m_Max) {}
  
  //translating a bounding box
  inline bb& operator+=(const Vect3D_t &v)
  { m_Min += v; m_Max += v; return *this; }
  inline const bb operator+(const Vect3D_t &v) const
  { return (bb(*this) += v); }

  //update the bounding box min/max coords with vertex v
  inline bb& operator<<(const Vect3D_t &v)
  {
    if (v.x < m_Min.x)      m_Min.x = v.x;
    else if (v.x > m_Max.x) m_Max.x = v.x;
    if (v.y < m_Min.y)      m_Min.y = v.y;
    else if (v.y > m_Max.y) m_Max.y = v.y;
    if (v.z < m_Min.z)      m_Min.z = v.z;
    else if (v.z > m_Max.z) m_Max.z = v.z;
    return *this;
  }

  inline bool Contains(const Vect3D_t &v) const
  {
    //check if the point is contained in the box
    return m_Min < v && v < m_Max;
  }

  inline bool Contains(const bb& b) const
  {
    return Contains(b.m_Min) && Contains(b.m_Max);
  }

  inline bool Overlap(const bb& rhs) const
  {

    return m_Min < rhs.m_Max && m_Max > rhs.m_Min;       
  }

} BoundingBox_t;


typedef struct triangle
{
  int v1, n1, t1,
      v2, n2, t2,
      v3, n3, t3;
} Triangle_t;

typedef struct mat
{
  GLfloat m_fAmb[4],
          m_fDif[4],
          m_fSpec[4],
          m_fEmi[4],
          m_fShin;

  //default constructor
  mat()   
  {
    m_fAmb[0] = m_fAmb[1] = m_fAmb[2] = 0.7f; m_fAmb[3] = 1.0f;
    m_fDif[0] = m_fDif[1] = m_fDif[3] = 0.7f; m_fDif[3] = 1.0f;
    m_fSpec[0] = m_fSpec[1] = m_fSpec[2] = m_fSpec[3] = 1.0f;
    m_fEmi[0] = m_fEmi[1] = m_fEmi[2] = 0.0f; m_fEmi[3] = 1.0f;
    m_fShin = 128.0f;
  }
  //for convenience
  inline void setAmb(float r, float g, float b, float a)
    { m_fAmb[0] = r; m_fAmb[1] = g; m_fAmb[2] = b; m_fAmb[3] = a; }
  inline void setDif(float r, float g, float b, float a)
    { m_fDif[0] = r; m_fDif[1] = g; m_fDif[2] = b; m_fDif[3] = a; }
  inline void setSpec(float r, float g, float b, float a)
    { m_fSpec[0] = r; m_fSpec[1] = g; m_fSpec[2] = b; m_fSpec[3] = a; }
  inline void setEmi(float r, float g, float b, float a)
    { m_fEmi[0] = r; m_fEmi[1] = g; m_fEmi[2] = b; m_fEmi[3] = a; }
            
} MatProps_t;
/*
typedef struct facegroup
{
  MatProps_t           m_material;
  std::vector<Face_t>  m_faces;
} FaceGroup_t;
*/

typedef struct geom
{
  std::vector<Vect3D_t> m_verts,
                        m_norms,
                        m_texs;
  std::vector<Triangle_t> m_triangles;
} Geometry_t;

typedef struct FrustumParms
{
  double m_dHeadTrackLedDist;       //distance between leds on head in millimeters
  double m_dRadPerCameraPixel;      //radians per camera pixel
  double m_dCameraXCenter;          //the coordinates of the center of the camera
  double m_dCameraYCenter;          //
  double m_dYAngleCorrection;       //the correction added to the verticle angle measured by the camera (in radians)
  double m_dCameraYOffset;          //the offset in Y direction of the camera relative to the center of the screen (in mm)
  double m_dScreenHeightMM;         //the height of the screen (in mm)
  double m_dScreenAspect;           //the aspect ratio of the screen (width/height)
  double m_dScreenHeightWorld;      //the height of the screen (in world coordinates)
  double m_dEyeDistMM;              //distance between the eyes (in mm)
  double m_dDefHeadDistMM;          //default distance between head and display (in mm)
  double m_dSensorbarLedDistMM;     //default distance between the leds on the sensorbar
} FrustumParms_t;

typedef enum EyeOrigin {
    STEREO_LEFT_EYE  = 0,
    STEREO_RIGHT_EYE = 1,
    MONO_CENTER      = 2
} EyeOrigin_t;


//forward class declaration
class AbstractWiimote;

typedef struct GameState
{
  FrustumParms_t  m_FrustumParms;
  bool            m_bHeadTrackingEnabled;
  bool            m_bStereoEnabled;
  //wiimote         *m_pTrackingWiimote;
  AbstractWiimote *m_pWiimote[2];
  GLuint          m_GreyScaleShaderProgram;   //handle to the grayscale shader program
  GLint           m_GSConvScaleLoc;           //handle to the g_ConversionScale variable in the shader
  GLfloat         m_GSConvScale[3];           //grayscale conversion scale (default 0.299, 0.587, 0.114)
} GameState_t;

#endif //TYPEDEFS_H