#pragma once
#include "cs2.h"
#include "../util.h"
#include "sdk.h"


inline CS2_SCHEMA_FIELD* schema_class_get_fields( CS2* p, CS2_SCHEMA_CLASS* schclass ) {
  if( !schclass->fields || !schclass->num_fields )
    return 0;
  
  U32               c = schclass->num_fields;
  CS2_SCHEMA_FIELD* fields = (CS2_SCHEMA_FIELD*)malloc( sizeof(CS2_SCHEMA_FIELD) * c );
  
  p->read( schclass->fields, fields, sizeof(CS2_SCHEMA_FIELD) * c );

  return fields;
}

inline CS2_SCHEMA_CLASS* schema_scope_get_classes( CS2* p, CS2_SCHEMA_SCOPE* scope ) {
  U32                        c = scope->num_classes;
  CS2_SCHEMA_ENTRY*          entries = (CS2_SCHEMA_ENTRY*)malloc( sizeof(CS2_SCHEMA_ENTRY) * (c) );
  CS2_SCHEMA_CLASS*          ret = (CS2_SCHEMA_CLASS*)malloc( sizeof(CS2_SCHEMA_CLASS) * (c) );
  
  p->read( scope->declared_classes, entries, sizeof(CS2_SCHEMA_ENTRY) * (c) );
  
  for( U32 i = 0; i < c; ++i ) {
    CS2_SCHEMA_ENTRY* e = &entries[i];

    CS2_SCHEMA_DECLARED_CLASS _class;
    p->read( e->declared_class, &_class, sizeof( _class ) );
    p->read( _class.class_ptr, &ret[i], sizeof(CS2_SCHEMA_CLASS) );
  }

  free( entries );
  return ret;
}

inline CS2_SCHEMA_SCOPE* schema_get_scopes( CS2* p, CS2_SCHEMA schema ) {
  U32               c = (U32)schema.scope_size;
  U64*              ptrarr = (U64*)malloc( sizeof(U64) * c );
  CS2_SCHEMA_SCOPE* ret = (CS2_SCHEMA_SCOPE*)malloc( sizeof(CS2_SCHEMA_SCOPE) * c );
  
  p->read( schema.scopes, ptrarr, sizeof(U64) * c );
  
  for( U32 i = 0; i < c; ++i ) {
    p->read( ptrarr[i], &ret[i], sizeof(CS2_SCHEMA_SCOPE) );
  }

  free( ptrarr );
  return ret;
}

inline CS2_SCHEMA schema_read_iface( CS2* p, U64 schemasys ) {
  CS2_SCHEMA ret;

  p->read( schemasys, &ret, sizeof(CS2_SCHEMA) );
  
  return ret;
}

// CAUTION: SLOW!!!!
static VECTOR<NETVAR_ENTRY> schema_get_all( CS2* p ) {
  VECTOR<NETVAR_ENTRY> entries;
  CS2_SCHEMA schema = schema_read_iface( p, p->iface.schema.ptr );
  CS2_SCHEMA_SCOPE* scopes = schema_get_scopes( p, schema );

  for( U32 i = 0; i < schema.scope_size; ++i ) {
    CS2_SCHEMA_SCOPE* scope = &scopes[i];
    
    if( !scope->declared_classes )
      continue;
    
    CS2_SCHEMA_CLASS* classes = schema_scope_get_classes( p, scope );

    for( U32 j = 0; j < scope->num_classes; ++j ) {
      CS2_SCHEMA_CLASS* schclass = &classes[j];

      STR<128> classname{};
      p->read( schclass->name, classname.data, 128 );

      if( classname.data[0] == 0 || !strlen( classname ) )
        continue;

      if( !schclass->fields || !schclass->num_fields )
        continue;
      
      CS2_SCHEMA_FIELD* fields = schema_class_get_fields( p, schclass );

      for( U32 k = 0; k < schclass->num_fields; ++k ) {
        CS2_SCHEMA_FIELD* field = &fields[k];
        NETVAR_ENTRY entry{};
        
        STR<256> buf;
        p->read( field->name, buf.data, 256 );
        entry.prop = buf;
        entry.clientclass = buf;
        entry.scope = scope->name;        
        entries.push_back( entry );
      }

      free( fields );
    }
    
    free( classes );
  }

  free( scopes );
  return entries; 
}

static void schema_dump_to_file( CS2* p ) {
  CS2_SCHEMA schema = schema_read_iface( p, p->iface.schema.ptr );

  static STR<9999999> output;
  memset( output, 0, sizeof(output.data) );

  sprintf( output.data, "schema: %llx %llx\n", schema.scopes, schema.scope_size );
  
  CS2_SCHEMA_SCOPE* scopes = schema_get_scopes( p, schema );

  for( U32 i = 0; i < schema.scope_size; ++i ) {
    CS2_SCHEMA_SCOPE* scope = &scopes[i];
    
    sprintf( output.data, "%s --scope %s: %d classes [%llx]\n", output.data, scope->name, scope->num_classes, scope->declared_classes );

    if( !scope->declared_classes )
      continue;
    
    CS2_SCHEMA_CLASS* classes = schema_scope_get_classes( p, scope );

    for( U32 j = 0; j < scope->num_classes; ++j ) {
      CS2_SCHEMA_CLASS* schclass = &classes[j];

      STR<128> classname{};
      p->read( schclass->name, classname.data, 128 );

      if( classname.data[0] == 0 || !strlen( classname ) )
        continue;

      sprintf( output.data, "%s ----class %s: %d fields\n", output.data, classname.data, schclass->num_fields );

      if( !schclass->fields || !schclass->num_fields )
        continue;
      
      CS2_SCHEMA_FIELD* fields = schema_class_get_fields( p, schclass );

      for( U32 k = 0; k < schclass->num_fields; ++k ) {
        CS2_SCHEMA_FIELD* field = &fields[k];
        
        STR<256> buf;
        p->read( field->name, buf.data, 256 );
        sprintf( output.data, "%s ------field %s 0x%x\n", output.data, buf.data, field->offset );
      }

      free( fields );
    }
    
    free( classes );
  }

  FILE* f = fopen( "schema.txt", "w" );
  fwrite( output.data, 1, strlen(output.data), f );
  fclose( f );
  
  free( scopes );
}