#version 300 es
layout ( location = 0 ) in vec3 position;
layout ( location = 1 ) in vec3 normaly;
layout ( location = 2 ) in vec4 color;
uniform mat4 transform;
uniform mat4 perspective;
uniform mat4 rotate;
out vec4 v_color;

void main ( )
{
  gl_Position = perspective * transform * vec4 ( position, 1.0 );
  v_color = color;
}

#version 300 es
precision mediump float;
in vec4 v_color;
layout ( location = 0 ) out vec4 out_color;
void main ( )
{
  out_color = v_color;
}

#ifndef __MODEL_H__
#define __MODEL_H__
#include "../glm/glm.hpp"
#include "../glm/ext.hpp"
#include "sprite.h"
#include "object.h"
#include "types.h"

struct frame {
    unsigned int length_v;
    unsigned int length_vt;
    unsigned int length_vn;

    float *v;
    float *vn;
    float *vt;

    unsigned int current_length;
};

struct with_t {
    int sampler_location;
    int transform_location;
    int perspective_location;
    int rotate_location;
};

struct without_t {
    int transform_location;
    int perspective_location;
    int rotate_location;
};

class Model : public Object {
    private:
  glm::mat4 proj;
  glm::mat4 view;
  glm::mat4 model;
  glm::mat4 rotate;
  glm::mat4 result;

  glm::vec4 color;

  struct frame *frames;

  unsigned int current_frame;

  unsigned int program_wit;
  unsigned int program_wiot;

  struct with_t wit;
  struct without_t wiot;

  unsigned int textureid;

  friend void draw_with_texture ( Model * );
  friend void draw_without_texture ( Model * );

  void (*map) ( Model * );

    public:
  int get_type ( ) {
   return Type::MODEL;
  }
  float x;
  float y;
  float z;
  Model ( );
  void read_file ( const char *file ) override;
  void draw ( ) override;
  void set_color ( glm::vec4 color );
  void switch_to ( void );
  void transform ( const glm::vec3 &translate );
  Sprite *texture;
};
#endif

#include "model.h"
#include <stdio.h>
#include <string.h>
#include "vars.h"
#include "conf.h"
#include "gl.h"

extern struct conf cf;

Model::Model ( ) {
    this->frames = nullptr;
    this->texture = nullptr;

    float aspect = ( float ) cf.screen_width / ( float ) cf.screen_height;

    this->proj = glm::perspective ( glm::radians ( 45.f ), aspect, 0.0f, 100.f );
    this->view = glm::translate ( glm::mat4 ( 1.0f ), glm::vec3 ( 0.f, 0.f, 0.f ) );
    this->model = glm::mat4 ( 1.0f );
    this->rotate = glm::mat4 ( 1.0f );

    this->current_frame = 0;

    this->program_wit = cf.programs [ SHADER_MODEL_WITH_TEXTURE ];
    this->program_wiot = cf.programs [ SHADER_MODEL_WITHOUT_TEXTURE ];

    int error;
    glUseProgram ( this->program_wit );
    this->wit.sampler_location = glGetUniformLocation ( this->program_wit, "s_texture" );
    this->wit.transform_location = glGetUniformLocation ( this->program_wit, "transform" );
    this->wit.perspective_location = glGetUniformLocation ( this->program_wit, "perspective" );
    this->wit.rotate_location = glGetUniformLocation ( this->program_wit, "rotate" );

    glUseProgram ( this->program_wiot );
    this->wiot.transform_location = glGetUniformLocation ( this->program_wiot, "transform" );
    this->wiot.perspective_location = glGetUniformLocation ( this->program_wiot, "perspective" );
    this->wiot.rotate_location = glGetUniformLocation ( this->program_wiot, "rotate" );
}

void Model::transform ( const glm::vec3 &translate ) {
    this->x = translate.x;
    this->y = translate.y;
    this->z = translate.z;
    this->view = glm::translate ( this->model, translate );
}

void Model::set_color ( glm::vec4 color ) {
    this->color = color;
}

void draw_with_texture ( Model *m ) {
    glUseProgram ( m->program_wit );

    glActiveTexture ( GL_TEXTURE0 );
    glBindTexture ( GL_TEXTURE_2D, m->textureid );

    glUniform1i ( m->wit.sampler_location, 0 );
    glUniformMatrix4fv ( m->wit.transform_location, 1, GL_FALSE, &m->view[0][0] );
    glUniformMatrix4fv ( m->wit.perspective_location, 1, GL_FALSE, &m->proj[0][0] );
    glUniformMatrix4fv ( m->wit.rotate_location, 1, GL_FALSE, &m->rotate[0][0] );

    glEnableVertexAttribArray ( 0 );
    glEnableVertexAttribArray ( 1 );
    glEnableVertexAttribArray ( 2 );

    glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, m->frames[m->current_frame].v );
    glVertexAttribPointer ( 1, 3, GL_FLOAT, GL_FALSE, 0, m->frames[m->current_frame].vn );
    glVertexAttribPointer ( 2, 2, GL_FLOAT, GL_FALSE, 0, m->frames[m->current_frame].vt );

    glDrawArrays ( GL_TRIANGLES, 0, m->frames[m->current_frame].length_v );

    glDisableVertexAttribArray ( 0 );
    glDisableVertexAttribArray ( 1 );
    glDisableVertexAttribArray ( 2 );
}

void draw_without_texture ( Model *m ) {
    glUseProgram ( m->program_wiot );

    glUniformMatrix4fv ( m->wiot.transform_location, 1, GL_FALSE, &m->view[0][0] );
    glUniformMatrix4fv ( m->wiot.perspective_location, 1, GL_FALSE, &m->proj[0][0] );
    glUniformMatrix4fv ( m->wiot.rotate_location, 1, GL_FALSE, &m->rotate[0][0] );

    glEnableVertexAttribArray ( 0 );
    glEnableVertexAttribArray ( 1 );
    glEnableVertexAttribArray ( 2 );

    glVertexAttribPointer ( 0, 3, GL_FLOAT, GL_FALSE, 0, m->frames[m->current_frame].v );
    glVertexAttribPointer ( 1, 3, GL_FLOAT, GL_FALSE, 0, m->frames[m->current_frame].vn );
    glVertexAttribPointer ( 2, 4, GL_FLOAT, GL_FALSE, 0, &m->color[0] );

    glDrawArrays ( GL_TRIANGLES, 0, m->frames[m->current_frame].current_length  );

    glDisableVertexAttribArray ( 0 );
    glDisableVertexAttribArray ( 1 );
    glDisableVertexAttribArray ( 2 );
}

void Model::switch_to ( ) {
    if ( this->texture ) this->map = draw_with_texture;
    else this->map = draw_without_texture;
}

void Model::draw ( ) {
    this->map ( this );
}

void Model::read_file ( const char *file ) {
    int count;

    char path[255] = { 0 };
    snprintf ( path, 254, "%s/models/%s", DEFAULT_ASSETS, file );
    FILE *fp = fopen ( path, "r" );
    fread ( &count, sizeof ( int ), 1, fp );
    this->frames = new struct frame [ count ];

    for ( int i = 0; i < count; i++ ) {
  fread ( &this->frames[i].length_v,  sizeof ( unsigned int ), 1, fp );
  fread ( &this->frames[i].length_vt, sizeof ( unsigned int ), 1, fp );
  fread ( &this->frames[i].length_vn, sizeof ( unsigned int ), 1, fp );

  this->frames[i].current_length = this->frames[i].length_v / 3;

  this->frames[i].v  = new float [ this->frames[i].length_v ];
  this->frames[i].vt = new float [ this->frames[i].length_vt ];
  this->frames[i].vn = new float [ this->frames[i].length_vn ];

  fread ( &this->frames[i].v[0],  sizeof ( float ), this->frames[i].length_v, fp );
  fread ( &this->frames[i].vn[0], sizeof ( float ), this->frames[i].length_vn, fp );
  fread ( &this->frames[i].vt[0], sizeof ( float ), this->frames[i].length_vt, fp );
    }

    fclose ( fp );
}