#include <errno.h>
#include <stdio.h>
#include <stdint.h> //uint64_t
#include <string.h> //memmove
#include <stdlib.h> //malloc
#include "ir.h"

#define CURR_CDAT (*cdat_stackp)
#define CURR_SET set_list[CURR_CDAT->num_sets]
#define CURR_ELE ele_list[CURR_CDAT->CURR_SET.num_ele]
#define PREV_REF (ref_buf[num_refs-1])
#define CURR_REF (ref_buf[num_refs])
#define PREV_ODAT (odat_buf[num_odats-1])
#define CURR_ODAT (odat_buf[num_odats])
#define CURR_VDAT (vdat_buf[num_vdats])
#define PREV_VDAT (vdat_buf[num_vdats-1])
#define CURR_MODEL model_list[CURR_VDAT->num_models]
#define CURR_LINK (link_buf[num_links])


void
ir_init()
{
  /* Init root cdat and stack */
  char root[4] = "root";

  cdat_buf[num_cdats] = (struct cdat*) malloc(sizeof(struct cdat) );
  cdat_buf[num_cdats]->idx = 0;
  memmove(cdat_buf[num_cdats]->name, root, 4);

  cdat_stackp = cdat_stack;
  *cdat_stackp = cdat_buf[num_cdats++];

  /* Init first odat */
  if( (CURR_ODAT = (struct odat*) malloc(sizeof(struct odat))) == NULL)
    perror("malloc first odat failed");

  /* init first vdat*/
  if( (CURR_VDAT = (struct vdat*) malloc(sizeof(struct vdat))) == NULL)
    perror("malloc first vdat failed");

  /* Init first ref */
  if( (CURR_REF = (struct ref*)  malloc(sizeof(struct ref))) == NULL)
    perror("malloc first ref failed");

  /* Init first link */
  if( (CURR_LINK = (struct link*) malloc(sizeof(struct link))) == NULL)
    perror("malloc first link failed");
}

//TODO: FREE MEMORY!
void
malloc_cdat()
{

  if(curr_max_cdats <= num_cdats)
    {
      if( (realloc((void*) cdat_buf, PTRS_IN_PAGE * 4)) == NULL)
        perror("realloc cdat_buf failed");
      curr_max_cdats += PTRS_IN_PAGE;
      if( (realloc( (void*) cdat_stack, PTRS_IN_PAGE * 4)) == NULL) //increase cdat_stack also
        perror("realloc cdat_stack failed");
    }
  if( (cdat_buf[num_cdats] = (struct cdat*) malloc(sizeof (struct cdat)) ) == NULL )
    perror("malloc cdat failed");


}

/* Dynamically allocate memory for a class data structure,
   or cdat, after a class has been identified in a grammar.
   We also create a stack of class pointers so that
   we can access the cdat during processing of that
   cdats sets and elements, a requirement because the
   nature of recursive classes prevents us from accessing
   the cdat based on the previous index into cdat_buf,
   which is a list of all allocated cdats*/
void
push_cdat(char* name)
{

  malloc_cdat();

  memmove(cdat_buf[num_cdats]->name, name, 32);
  cdat_buf[num_cdats]->idx = num_cdats;

  /* Set the cdat as a class of the previous cdat */
  (*cdat_stackp)->class_list[(*cdat_stackp)->num_classes++] = cdat_buf[num_cdats];

  /* Push the cdat onto the cdat_stack */
  *++cdat_stackp = cdat_buf[num_cdats++];

}

void
pop_cdat()
{
  *cdat_stackp = NULL;
  cdat_stackp--;
}

void
inc_odat()
{
  num_odats++;
  if(num_odats >= curr_max_odats)
    {
      if( (realloc((void*) odat_buf, PTRS_IN_PAGE * 4)) == NULL)
        perror("realloc odat_buf failed");
      curr_max_odats += PTRS_IN_PAGE;
    }
  if( (CURR_ODAT = (struct odat*) malloc(sizeof (struct odat))) == NULL)
    {
      perror("malloc odat failed");
    }

}

void
inc_vdat()
{
  num_vdats++;
  if(num_vdats >= curr_max_vdats)
    {
      if( (realloc((void*) vdat_buf, PTRS_IN_PAGE * 4)) == NULL)
        perror("realloc vdat_buf failed");
      curr_max_vdats += PTRS_IN_PAGE;
    }
  if((CURR_VDAT = (struct vdat*) malloc(sizeof (struct vdat))) == NULL)
    {
      perror("malloc vdat failed");
    }

}

void
inc_link()
{
  num_links++;
  if(num_links >= curr_max_links)
    {
      if( (realloc((void*) link_buf, PTRS_IN_PAGE * 4)) == NULL)
        perror("realloc vdat_buf failed");
      curr_max_links += PTRS_IN_PAGE;
    }
  if((CURR_LINK = (struct link*) malloc(sizeof (struct link))) == NULL)
    {
      perror("malloc link failed");
    }
}

void
inc_ref()
{

  if(num_refs % 16 == 0)
    {
      posts[num_posts++] = *CURR_REF;
    }

  num_refs++;
  if(num_refs >= curr_max_refs)
    {
      if( (realloc((void*) ref_buf, PTRS_IN_PAGE * 4)) == NULL)
        perror("realloc ref_buf failed");
      curr_max_refs += PTRS_IN_PAGE;
    }
  if((CURR_REF = (struct ref*) malloc(sizeof (struct ref))) == NULL)
    perror("malloc ref failed");
}

void
insert_set_label(char* name, uint64_t ref_id)
{


  memmove(CURR_CDAT->CURR_SET.name,name,32);
  memmove(&CURR_CDAT->CURR_SET.ref_id,&ref_id,64);

}
void
insert_set_olink(uint64_t ref_id)
{
  CURR_CDAT->CURR_SET.cdat_idx = CURR_CDAT->idx;
  CURR_CDAT->CURR_SET.ref_id = ref_id; /* Will be resolved to offset
                                          when link is processed */
  CURR_LINK->type = 1;
  CURR_LINK->link_t.olink.ref_id = ref_id;
  CURR_LINK->cdat_idx = CURR_CDAT->idx;
  CURR_LINK->set_idx = CURR_CDAT->num_sets++;
  CURR_LINK->ele_idx = -1;

  inc_link();
}

void
insert_set_vlink(uint64_t ref_id, char* anim_name)
{
  /* Insert vlink into link_stack so that it gets processed at
     output time */
  CURR_LINK->cdat_idx = CURR_CDAT->idx;
  CURR_LINK->set_idx = CURR_CDAT->num_sets;
  CURR_LINK->type = 2;
  CURR_LINK->link_t.vlink.ref_id = ref_id;
  memmove(CURR_LINK->link_t.vlink.anim_name, anim_name, 32);


}

void
insert_set_svlink(uint64_t ref_id)
{

  /* Insert vlink into link_stack so that it gets processed at
     output time */
  CURR_LINK->cdat_idx = CURR_CDAT->idx;
  CURR_LINK->set_idx = CURR_CDAT->num_sets;
  CURR_LINK->type = 3;
  CURR_LINK->link_t.svlink.ref_id = ref_id;

}

/* At the point of reducing to a set, most of the
   sets odat information has already been populated
   during the reduction of its right hand side
   non terminals (hitbox, root, quad_list). */
void
insert_set()
{
  uint64_t ref_id;

  ref_id = CURR_CDAT->CURR_SET.ref_id;

  CURR_CDAT->CURR_SET.cdat_idx = CURR_CDAT->idx;
  memmove(CURR_ODAT->name, CURR_CDAT->CURR_SET.name, 32);
  CURR_CDAT->num_sets++;

  CURR_ODAT->cdat_idx = CURR_CDAT->idx;
  CURR_ODAT->refp = CURR_REF;


  CURR_REF->lastref = PREV_REF;
  PREV_REF->nextref = CURR_REF;
  CURR_REF->odatp = CURR_ODAT;


  if(ref_id == -1) /* user did not define a ref_id so */
    {              /* use a ref_id from system_space  */
      ref_id = ss_ref_id;
      ss_ref_id++;
    }

  CURR_REF->ref_id = ref_id;



  inc_ref();
  inc_odat();
}

void
insert_vdat()
{
  PREV_ODAT->vdat_id = num_vdats; //NULL for vlink, svlink
  inc_vdat();
}

/* Populates both the odat name and ref_id
   for element. */
void
insert_ele_label(char* name, uint64_t ref_id)
{
  memmove(CURR_CDAT->CURR_SET.CURR_ELE.name, name, 32);
  memmove(&CURR_CDAT->CURR_SET.ele_list[CURR_CDAT->CURR_SET.ref_id].ref_id, &ref_id, 64);
}

void
insert_ele_olink(uint64_t ref_id)
{
  CURR_CDAT->CURR_SET.CURR_ELE.cdat_idx = CURR_CDAT->idx;
  CURR_CDAT->CURR_SET.CURR_ELE.ref_id = ref_id; /* Will be resolved to offset
                                                   when link is processed */
  CURR_LINK->type = 1;
  CURR_LINK->link_t.olink.ref_id = ref_id;
  CURR_LINK->cdat_idx = CURR_CDAT->idx;
  CURR_LINK->set_idx = CURR_CDAT->num_sets++;
  CURR_LINK->ele_idx = CURR_CDAT->CURR_SET.num_ele++;

}
void
insert_ele_vlink(uint64_t ref_id, char* anim_name)
{

  /* Insert vlink into link_stack so that it gets processed at
     output time */
  CURR_LINK->cdat_idx = CURR_CDAT->idx;
  CURR_LINK->type = 2;
  CURR_LINK->set_idx = CURR_CDAT->num_sets;
  CURR_LINK->ele_idx = CURR_CDAT->CURR_SET.num_ele;
  CURR_LINK->link_t.vlink.ref_id = ref_id;
  memmove(CURR_LINK->link_t.vlink.anim_name, anim_name, 32);


}
void
insert_ele_svlink(uint64_t ref_id)
{

  CURR_LINK->cdat_idx = CURR_CDAT->idx;
  CURR_LINK->type = 3;
  CURR_LINK->set_idx = CURR_CDAT->num_sets;
  CURR_LINK->ele_idx = CURR_CDAT->CURR_SET.num_ele;
  CURR_LINK->link_t.svlink.ref_id = ref_id;


}
//Insert element into odat_buf and cdatpages
void
insert_ele()
{

  uint64_t ref_id;

  ref_id = CURR_CDAT->CURR_SET.CURR_ELE.ref_id;

  CURR_CDAT->CURR_SET.CURR_ELE.cdat_idx = CURR_CDAT->idx;
  memmove(CURR_ODAT->name,CURR_CDAT->CURR_SET.CURR_ELE.name, 32);
  CURR_CDAT->CURR_SET.num_ele++;

  CURR_ODAT->cdat_idx = CURR_CDAT->idx;
  CURR_ODAT->refp = CURR_REF;

  if(ref_id == -1) /* user did not define a ref_id so */
    {              /* use a ref_id from system_space  */
      ref_id = ss_ref_id;
      ss_ref_id++;
    }

  CURR_REF->ref_id = ref_id;

  inc_odat();
  inc_ref();

}

void
insert_framesheets(char direction, char* name, uint64_t ref_id, int height , int width, int num_frames)
{
  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].height = height;
  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].width = width;
  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].num_frames = num_frames;
  CURR_VDAT->num_models++;
}

#define CURR_QUAD (CURR_ODAT->quad_list[CURR_ODAT->num_quads])
void
insert_quad(int x, int y, int z, uint64_t ref_id)
{
  CURR_QUAD.x = x;
  CURR_QUAD.y = y;
  CURR_QUAD.z = z;
  CURR_QUAD.ref_id = ref_id;
  CURR_ODAT->num_quads++;
}

/* Inserting the hitbox into the set
   odat. Elements that don't have
   a hitbox will use the sets root. */
void
insert_hitbox(int hitbox)
{
  CURR_ODAT->hitbox = hitbox;
}

/* Inserting the root into the set
   odat. Elements that don't have
   a root will use the sets root. */
void
insert_root(int x, int y, int z)
{

  CURR_ODAT->root.x = x;
  CURR_ODAT->root.y = y;
  CURR_ODAT->root.z = z;
}

void
insert_frame_pointer(char direction, void* frame)
{
  CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].frames[CURR_VDAT->CURR_MODEL.spritesheet[(int)direction].num_frames++] = frame;
}