#include "oploader.h"
#include "php.h"
#include "zend_execute.h"
#include <stdio.h>

static intptr_t handlers_base_address = 0;

void load_oparray(FILE* fp, zend_op_array* oparray)
{
    fload(&(oparray->type), sizeof(oparray->type), 1, fp);
    fload(&(oparray->arg_flags), sizeof(oparray->arg_flags[0]), 3, fp);
    fload(&(oparray->fn_flags), sizeof(oparray->fn_flags), 1, fp);
    load_zend_string(fp, &(oparray->function_name));
    load_class_entry(fp, &(oparray->scope));
    load_zend_function(fp, &(oparray->prototype));
    fload(&(oparray->num_args), sizeof(oparray->num_args), 1, fp);
    fload(&(oparray->required_num_args), sizeof(oparray->required_num_args), 1, fp);
    load_arg_info(fp, &(oparray->arg_info));
    fload(&(oparray->this_var), sizeof(oparray->this_var), 1, fp);
    fload(&(oparray->last), sizeof(oparray->last), 1, fp);
    load_opcodes(fp, &(oparray->opcodes), oparray->last);
    fload(&(oparray->last_var), sizeof(oparray->last_var), 1, fp);
    fload(&(oparray->T), sizeof(oparray->T), 1, fp);
    load_vars(fp, &(oparray->vars), oparray->last_var);
    fload(&(oparray->last_brk_cont), sizeof(oparray->last_brk_cont), 1, fp);
    fload(&(oparray->last_try_catch), sizeof(oparray->last_try_catch), 1, fp);
    load_brk_cont_array(fp, &(oparray->brk_cont_array), oparray->last_brk_cont);
    load_try_catch_array(fp, &(oparray->try_catch_array), oparray->last_try_catch);
    load_hashtable(fp, &(oparray->static_variables));
    load_zend_string(fp, &(oparray->filename));
    fload(&(oparray->line_start), sizeof(oparray->line_start), 1, fp);
    fload(&(oparray->line_end), sizeof(oparray->line_end), 1, fp);
    load_zend_string(fp, &(oparray->doc_comment));
    fload(&(oparray->early_binding), sizeof(oparray->early_binding), 1, fp);
    fload(&(oparray->last_literal), sizeof(oparray->last_literal), 1, fp);
    load_literals(fp, &(oparray->literals), oparray->last_literal);
    fload(&(oparray->cache_size), sizeof(oparray->cache_size), 1, fp);
    load_runtime_cache(fp, &(oparray->run_time_cache), oparray->cache_size);
}

void load_opcodes(FILE* fp, zend_op** opcodes, uint32_t count)
{
    uint32_t i;
    void* addr;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        *opcodes = malloc(sizeof(zend_op)*count);
        for (i = 0; i < count; i++) {
            load_zend_op(fp, &((*opcodes)[i]));
        }
    } else {
        *opcodes = NULL;
    }
}

void load_zend_op(FILE* fp, zend_op* op)
{
    intptr_t offset;

    fload(&offset, sizeof(offset), 1, fp);
    op->handler = get_handler_by_offset(offset);
    load_znode_op(fp, &(op->op1), &(op->op1_type));
    load_znode_op(fp, &(op->op2), &(op->op2_type));
    load_znode_op(fp, &(op->result), &(op->result_type));
    fload(&(op->extended_value), sizeof(op->extended_value), 1, fp);
    fload(&(op->lineno), sizeof(op->lineno), 1, fp);
    fload(&(op->opcode), sizeof(op->opcode), 1, fp);
}

void load_znode_op(FILE* fp, znode_op* node, zend_uchar* type)
{
    fload(type, sizeof(*type), 1, fp);
    switch(*type) {
        case IS_UNDEF:
        case IS_UNUSED:
            break;
        case IS_CONST:
        case IS_VAR:
        case IS_TMP_VAR:
        case IS_CV:
        case 36:
            fload(&(node->var), sizeof(node->var), 1, fp);
            break;
        default:
            debug("ERROR: %d\n", type);
    }
}

void load_literals(FILE* fp, zval** literals, int count)
{
    void* addr;
    int i;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        *literals = malloc(sizeof(zval) * count);
        for (i = 0; i < count; i++) {
            load_zval(fp, &((*literals)[i]));
        }
    } else {
        *literals = NULL;
    }
}

void load_zval(FILE* fp, zval* val)
{
    fload(&(val->u1), sizeof(val->u1), 1, fp);
    fload(&(val->u2), sizeof(val->u2), 1, fp);
    switch(Z_TYPE_P(val)) {
        case IS_NULL:
        case IS_TRUE:
        case IS_FALSE:
            break;
        case IS_LONG:
            fload(&(val->value.lval), sizeof(val->value.lval), 1, fp);
            break;
        case IS_DOUBLE:
            fload(&(val->value.dval), sizeof(val->value.dval), 1, fp);
            break;
        case IS_STRING:
            load_zend_string(fp, &(val->value.str));
            break;
        default:
            debug("ZVAL type not implemented yet: %d\n.", Z_TYPE_P(val));
    }
}

void load_vars(FILE* fp, zend_string*** vars, int count)
{
    void* addr;
    int i;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        *vars = malloc(sizeof(zend_string*) * count);
        for (i = 0; i < count; i++) {
            load_zend_string(fp, &((*vars)[i]));
        }
    } else {
        *vars = NULL;
    }
}

void load_zend_string(FILE* fp, zend_string** str)
{
    void* addr = NULL;
    size_t len;
    char* buffer;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        fload(&len, sizeof(len), 1, fp);
        buffer = malloc(sizeof(char)*len);
        fload(buffer, sizeof(char), len, fp);
        *str = zend_string_init(buffer, len, 0);
        free(buffer);
    } else {
        *str = NULL;
    }
}

void load_class_entry(FILE* fp, zend_class_entry** ce)
{
    void* addr = NULL;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        debug("NON-NULL class entry!");
    } else {
        *ce = NULL;
    }
}

void load_zend_function(FILE* fp, zend_function** func)
{
    void* addr = NULL;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        debug("NON-NULL zend_function!\n");
    } else {
        *func = NULL;
    }
}

void load_arg_info(FILE* fp, zend_arg_info** info)
{
    void* addr = NULL;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        debug("NON_NULL ZEND_ARG_INFO\n");
    } else {
        *info = NULL;
    }
}

void load_brk_cont_array(FILE* fp, zend_brk_cont_element** array, int count)
{
    void* addr = NULL;
    int i;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        *array = malloc(sizeof(zend_brk_cont_element) * count);
        for (i = 0; i < count; i++) {
            load_brk_cont_element(fp, &((*array)[i]));
        }
    } else {
        *array = NULL;
    }
}

void load_brk_cont_element(FILE* fp, zend_brk_cont_element* elem)
{
    debug("load_brk_cont_element NOT IMPLEMENTED yet.\n");
}

void load_try_catch_array(FILE* fp, zend_try_catch_element** array, int count)
{
    void* addr = NULL;
    int i;

    fload(&(addr), sizeof(addr), 1, fp);
    if (addr != NULL) {
        *array = malloc(sizeof(zend_try_catch_element) * count);
        for (i = 0; i < count; i++) {
            load_try_catch_element(fp, &((*array)[i]));
        }
    } else {
        *array = NULL;
    }
}

void load_try_catch_element(FILE* fp, zend_try_catch_element* elem)
{
    debug("load_try_catch_element NOT IMPLEMENTED yet.\n");
}

void load_hashtable(FILE* fp, HashTable** table)
{
    void* addr = NULL;

    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        debug("load_hashtable NOT IMPLEMENTED yet.\n");
    } else {
        *table = NULL;
    }
}

void load_runtime_cache(FILE* fp, void*** cache, int count)
{
    void* addr = NULL;
    fload(&addr, sizeof(addr), 1, fp);
    if (addr != NULL) {
        debug("load_runtime_cache NOT DONE: %d.\n", count);
    } else {
        *cache = NULL;
    }
}

void* get_handler_by_offset(intptr_t offset)
{
    const void* base_handler;
    zval str;

    if (handlers_base_address == 0) {
        ZVAL_STRING(&str, "echo 1;");
        base_handler = zend_compile_string(&str, "")->opcodes[0].handler;
        handlers_base_address = (intptr_t)base_handler;
    }

    return (void*)(handlers_base_address + offset);
}

void fload(void* dest, size_t size, size_t n, FILE* fp)
{
    size_t result = fread(dest, size, n, fp);
    if (result != n) {
        debug("fload error\n");
    }
}

void debug(const char* fmt, ...)
{
    FILE* debug = fopen("/home/jfgauron/tmp/debug2.txt", "a");
    if (debug != NULL) {
        va_list args;
        va_start(args, fmt);
        vfprintf(debug, fmt, args);
        va_end(args);

        fflush(debug);
        fclose(debug);
    }
}