#ifndef __LARGEPOS_H__
#define __LARGEPOS_H__

#include <glm/ext/vector_float3.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#define MAX_DOUBLE 1000000.0

// a class to preserve the exact position of object's positions in deep space
class largePos{
public:
  //position in Mm (Megameteres)
  long long int ix=0;
  long long int iy=0;
  long long int iz=0;
  
  //position down to µm (in m)
  long double fx=0.0;
  long double fy=0.0;
  long double fz=0.0;

  // convert mega big brain int + float into normal opengl understandable stuff glm::vec4(x,y,z, object scale)
  glm::vec4 toFloatSpace(long double scale, largePos point){
    long double Mm=scale/1e6;
    float x = (ix-point.ix)/Mm;
    float y = (iy-point.iy)/Mm;
    float z = (iz-point.iz)/Mm;

    x+=(fx-point.fx)/scale;
    y+=(fy-point.fy)/scale;
    z+=(fz-point.fz)/scale;

    return glm::vec4(-x,-y,-z,scale);
  };

  largePos operator+(largePos b){
    largePos ret = *this;

    ret.ix+=b.ix;
    ret.iy+=b.iy;
    ret.iz+=b.iz;

    ret.fx+=b.fx;
    ret.fy+=b.fy;
    ret.fz+=b.fz;

    if(ret.fx>MAX_DOUBLE){
        ret.ix+=1; ret.fx=(this->fx-MAX_DOUBLE)+b.fx;
    }
    if(ret.fx<-MAX_DOUBLE){
        ret.ix-=1; ret.fx=(this->fx+MAX_DOUBLE)+b.fx;
    }

    if(ret.fy>MAX_DOUBLE){
        ret.iy+=1; ret.fy=(this->fy-MAX_DOUBLE)+b.fy;
    }
    if(ret.fy<-MAX_DOUBLE){
        ret.iy-=1; ret.fy=(this->fy+MAX_DOUBLE)+b.fy;
    }

    if(ret.fz>MAX_DOUBLE){
        ret.iz+=1; ret.fz=(this->fz-MAX_DOUBLE)+b.fz;
    }
    if(ret.fz<-MAX_DOUBLE){
        ret.iz-=1; ret.fz=(this->fz+MAX_DOUBLE)+b.fz;
    }

    return ret;
  }

  largePos operator-(){
    largePos ret;

    ret.ix=-this->ix;
    ret.iy=-this->iy;
    ret.iz=-this->iz;

    ret.fx=-this->fx;
    ret.fy=-this->fy;
    ret.fz=-this->fz;

    return ret;
  }

  largePos operator-(largePos b){
    return *this + -b;
  }

  largePos operator=(largePos b){
    ix=b.ix;
    iy=b.iy;
    iz=b.iz;

    fx=b.fx;
    fy=b.fy;
    fz=b.fz;

    return *this;
  }

  largePos operator+(glm::vec3 b){
    largePos ret;
    ret.fx=b.x;
    ret.fy=b.y;
    ret.fz=b.z;
    ret = *this+ret;

    // if(ret.fx>MAX_DOUBLE){
    //     ret.ix+=1; ret.fx=(this->fx-MAX_DOUBLE)+b.x;
    // }
    // if(ret.fx<-MAX_DOUBLE){
    //     ret.ix-=1; ret.fx=(this->fx+MAX_DOUBLE)+b.x;
    // }

    // if(ret.fy>MAX_DOUBLE){
    //     ret.iy+=1; ret.fy=(this->fy-MAX_DOUBLE)+b.y;
    // }
    // if(ret.fy<-MAX_DOUBLE){
    //     ret.iy-=1; ret.fy=(this->fy+MAX_DOUBLE)+b.y;
    // }

    // if(ret.fz>MAX_DOUBLE){
    //     ret.iz+=1; ret.fz=(this->fz-MAX_DOUBLE)+b.z;
    // }
    // if(ret.fz<-MAX_DOUBLE){
    //     ret.iz-=1; ret.fz=(this->fz+MAX_DOUBLE)+b.z;
    // }

    return ret;
  }

  largePos operator-(glm::vec3 b){
    return *this + -b;
  }

  largePos operator+=(largePos b){
    largePos ret=*this+b;
    *this=ret;
    return ret;
  }

  largePos operator-=(largePos b){
    largePos ret=*this-b;
    *this=ret;
    return ret;
  }

  largePos operator+=(glm::vec3 b){
    largePos ret=*this+b;
    *this=ret;
    return ret;
  }
  largePos operator-=(glm::vec3 b){
    largePos ret=*this-b;
    *this=ret;
    return ret;
  }

private:
};

#endif