#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>

#include <ffi.h>
#include "hacking.h"

#include "Clean.h"
#include "cleanstring.h"

void* parameters[100];
ffi_type* parameter_types[100];
uint8_t param_ptr = 0;

ffi_type* return_type;
void* return_val;

void cleanInit(void) {
    parameters[0] = NULL;
    param_ptr = 0;
}

void cleanPuti(long i) {
    parameters[param_ptr] = malloc(sizeof(long));
    *((long*)parameters[param_ptr]) = i;
    parameter_types[param_ptr] = &ffi_type_slong;
    param_ptr++;
}

void cleanPuts(CleanString s) {
    char** csptr = malloc(sizeof(char**));
    *csptr = cleantocstring(s);
    parameters[param_ptr] = csptr;
    parameter_types[param_ptr] = &ffi_type_pointer;
    param_ptr++;
}

void cleanPutr(double r) {
    parameters[param_ptr] = malloc(sizeof(double));
    *((double*)parameters[param_ptr]) = r;
    parameter_types[param_ptr] = &ffi_type_double;
    param_ptr++;
}

void cleanSetReturnType(long i) {
    switch (i) {
        case 0: 
            return_type = &ffi_type_slong; 
            return_val = calloc(sizeof(long), 1);
            break;
        case 1: 
            return_type = &ffi_type_pointer; 
            return_val = calloc(sizeof(char*), 1);
            break;
        case 2: 
            return_type = &ffi_type_double; 
            return_val = calloc(sizeof(double), 1);
            break;
    }
}

void cleanCall(CleanString fname) {
    char*cfname = cleantocstring(fname);
    
    Callable *callable = funcnameToCallable(cfname,
            param_ptr, parameter_types, return_type);

    if (callable != NULL)
        call(callable, parameters, return_val);

    for (; param_ptr != 0; param_ptr--)
        free(parameters[param_ptr - 1]);
}

CleanString* cleanGets(void) {
    return (CleanString*) ctocleanstring(*((char**)return_val));
}

long cleanGeti(void) {
    return (long) *((long*) return_val);
}

double cleanGetr(void) {
    return (double) *((double*) return_val);
}