#include "vars.h"
#include "../util.h"
#include <string.h>

VAR_LIST* varl;

void vars_check_global_list() {
  if( !varl )
    varl = vars_init();
}

VAR_LIST* vars_init() {
  VAR_LIST* ret = new VAR_LIST;
  return ret;
}

CVAR* var_new( const char* name, F32 v ) {
  vars_check_global_list();

  CVAR* ret = new CVAR;
  memset( ret, 0 , sizeof( CVAR ) );
  ret->type = CVAR_TYPE_FLOAT;
  ret->name = name;
  ret->fl_v = v;

  varl->vars.push( ret );
  return ret;
}

CVAR* var_new( const char* name, I32 i ) {
  vars_check_global_list();

  CVAR* ret = new CVAR;
  memset( ret, 0 , sizeof( CVAR ) );
  ret->type = CVAR_TYPE_INT;
  ret->name = name;
  ret->i_v = i;

  varl->vars.push( ret );
  return ret;
}

CVAR* var_new( const char* name, CLR c ) {
  vars_check_global_list();

  CVAR* ret = new CVAR;
  memset( ret, 0 , sizeof( CVAR ) );
  ret->type = CVAR_TYPE_COLOR;
  ret->name = name;
  ret->clr_v = c;

  varl->vars.push( ret );
  return ret;
}

CVAR* var_new( const char* name, CVAR_FUNC func ) {
  vars_check_global_list();

  CVAR* ret = new CVAR;
  memset( ret, 0 , sizeof( CVAR ) );
  ret->type = CVAR_TYPE_FN;
  ret->name = name;
  ret->fn_v = func;

  varl->vars.push( ret );
  return ret;
}

CVAR* var_new( const char* name, const char* v ) {
  vars_check_global_list();

  CVAR* ret = new CVAR;
  memset( ret, 0, sizeof( CVAR ) );
  ret->type = CVAR_TYPE_STRING;
  ret->name = name;

  varl->vars.push( ret );
  return ret;
}

CVAR* var_find( const char* name ) {
  if( !varl ) {
    dlog( "var_new() : error: varl null\n" );
    return 0;
  }

  U32 len = strlen( name );
  for( U32 i = 0; i < varl->vars.size; ++i ) {
    U32 len2 = strlen( varl->vars[i]->name );
    if( strncmp( varl->vars[i]->name, name, min( len, len2 ) ) == 0 ) {
      return varl->vars[i];
    }
  }

  return 0;
}

I32 var_call( CVAR *cmdvar, const char *cmdline ) {
  if( cmdvar->type != CVAR_TYPE_FN ) {
    dlog( "var_call() : error: not a function\n" );
    return -1;
  }

  return cmdvar->fn_v( cmdvar, cmdline );
}

F32 var_getf( CVAR *var ) {
  switch( var->type ) {
  case CVAR_TYPE_FLOAT: return var->fl_v;
  case CVAR_TYPE_INT: return (F32)var->i_v;
  default: return 0.f;
  }
}

I32 var_geti( CVAR *var ) {
  switch( var->type ) {
  case CVAR_TYPE_INT: return var->i_v;
  case CVAR_TYPE_FLOAT: return (I32)var->fl_v;
  default: return 0;
  }
}

CLR var_getclr( CVAR *var ) {
  switch( var->type ) {
  case CVAR_TYPE_COLOR: return var->clr_v;
  case CVAR_TYPE_FLOAT: return (CLR){ var->fl_v, var->fl_v, var->fl_v, 1.f };
  default: return {};
  }
}

const char* var_gets( CVAR *var ) {
  switch( var->type ) {
  case CVAR_TYPE_STRING: return var->str_v;
  case CVAR_TYPE_FLOAT:
    sprintf( var->str_v + sizeof(F32), "%f", var->fl_v );
    return var->str_v + sizeof(F32);
  case CVAR_TYPE_INT:
    sprintf( var->str_v + sizeof(I32), "%d", var->i_v );
    return var->str_v + sizeof(I32);
  case CVAR_TYPE_COLOR:
    sprintf( var->str_v + sizeof(CLR), "%f %f %f %f", var->clr_v.r, var->clr_v.g, var->clr_v.b, var->clr_v.a );
    return var->str_v + sizeof(CLR);
  default:
    return "";
  }
}

void var_set( CVAR* var, F32 v ) {
  switch( var->type ) {
  case CVAR_TYPE_FLOAT:
    var->fl_v = v; break;
  case CVAR_TYPE_INT:
    var->i_v = (I32)v; break;
  case CVAR_TYPE_COLOR:
    var->clr_v = (CLR){ v, v, v, 1.f }; break;
  case CVAR_TYPE_STRING:
    strcpy( var->str_v, to_str( v ) ); break;
  default: break;
  }
}

void var_set( CVAR* var, I32 v ) {
  switch( var->type ) {
  case CVAR_TYPE_FLOAT:
    var->fl_v = (F32)v; break;
  case CVAR_TYPE_INT:
    var->i_v = v; break;
  case CVAR_TYPE_COLOR:
    var->clr_v = (CLR){ ((F32)v / 255), ((F32)v / 255), ((F32)v / 255), 1.f }; break;
  case CVAR_TYPE_STRING:
    strcpy( var->str_v, to_str( v ) ); break;
  default: break;
  }
}

void var_set( CVAR* var, CLR v ) {
  switch( var->type ) {
  case CVAR_TYPE_COLOR:
    var->clr_v = v; break;
  case CVAR_TYPE_STRING:
    strcpy( var->str_v, to_str( v ) ); break;
  default: dlog( "attempted to set color to %s, but it's not a color value", var->name.data ); break;
  }
}

void var_set( CVAR* var, STR v ) {
  if( v.size >= 64 ) {
    dlog( "attempted to set string to %s, but it's too long (%d/64 bytes)", var->name.data, v.size );
    return;
  }

  switch( var->type ) {
    case CVAR_TYPE_FLOAT:
      F32 f; sscanf( v.data, "%f", &f );
      var->fl_v = f; break;
    case CVAR_TYPE_INT:
      var->i_v = atoi( v.data ); break;
    case CVAR_TYPE_STRING:
      strcpy( var->str_v, v.data ); break;
    case CVAR_TYPE_COLOR: {
      LIST<STR> strings = v.split( " " );
      if( strings.size < 3 || strings.size > 4 )
        break;

      for( U32 i = 0; i < strings.size; ++i ) {
        F32 f{}; sscanf( strings[i].data, "%f", &f );
        ( (F32*)( &var->clr_v ) )[i] = f;
      } break;
    }
    default:
      break;
  }
}