#include "opdumper.h"
#include "php.h"
#include "zend_execute.h"

static intptr_t handlers_base_address = 0;

void dump_oparray(FILE* fp, zend_op_array* oparray)
{
    fwrite(&(oparray->type), sizeof(oparray->type), 1, fp);
    fwrite(&(oparray->arg_flags), sizeof(oparray->arg_flags[0]), 3, fp);
    fwrite(&(oparray->fn_flags), sizeof(oparray->fn_flags), 1, fp);
    dump_zend_string(fp, oparray->function_name);
    dump_class_entry(fp, oparray->scope);
    dump_zend_function(fp, oparray->prototype);
    fwrite(&(oparray->num_args), sizeof(oparray->num_args), 1, fp);
    fwrite(&(oparray->required_num_args), sizeof(oparray->required_num_args), 1, fp);
    dump_arg_info(fp, oparray->arg_info);
    fwrite(&(oparray->this_var), sizeof(oparray->this_var), 1, fp);
    fwrite(&(oparray->last), sizeof(oparray->last), 1, fp);
    dump_opcodes(fp, oparray->opcodes, oparray->last);
    fwrite(&(oparray->last_var), sizeof(oparray->last_var), 1, fp);
    fwrite(&(oparray->T), sizeof(oparray->T), 1, fp);
    dump_vars(fp, oparray->vars, oparray->last_var);
    fwrite(&(oparray->last_brk_cont), sizeof(oparray->last_brk_cont), 1, fp);
    fwrite(&(oparray->last_try_catch), sizeof(oparray->last_try_catch), 1, fp);
    dump_brk_cont_array(fp, oparray->brk_cont_array, oparray->last_brk_cont);
    dump_try_catch_array(fp, oparray->try_catch_array, oparray->last_try_catch);
    dump_hashtable(fp, oparray->static_variables);
    dump_zend_string(fp, oparray->filename);
    fwrite(&(oparray->line_start), sizeof(oparray->line_start), 1, fp);
    fwrite(&(oparray->line_end), sizeof(oparray->line_end), 1, fp);
    dump_zend_string(fp, oparray->doc_comment);
    fwrite(&(oparray->early_binding), sizeof(oparray->early_binding), 1, fp);
    fwrite(&(oparray->last_literal), sizeof(oparray->last_literal), 1, fp);
    dump_literals(fp, oparray->literals, oparray->last_literal);
    fwrite(&(oparray->cache_size), sizeof(oparray->cache_size), 1, fp);
    dump_runtime_cache(fp, oparray->run_time_cache, oparray->cache_size);
}

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

    fwrite(&(opcodes), sizeof(void*), 1, fp);
    for (i = 0; i < count; i++) {
        dump_zend_op(fp, opcodes[i]);
    }
}

void dump_zend_op(FILE* fp, zend_op op)
{
    intptr_t offset = handler_offset(op.handler);

    size_t pos = ftell(fp);
    fwrite(&offset, sizeof(offset), 1, fp);
    dump_znode_op(fp, op.op1, op.op1_type);
    dump_znode_op(fp, op.op2, op.op2_type);
    dump_znode_op(fp, op.result, op.result_type);
    fwrite(&(op.extended_value), sizeof(op.extended_value), 1, fp);
    fwrite(&(op.lineno), sizeof(op.lineno), 1, fp);
    fwrite(&(op.opcode), sizeof(op.opcode), 1, fp);
}

void dump_znode_op(FILE* fp, znode_op node, zend_uchar type)
{
    fwrite(&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: // SPEC(RETVAL)
            fwrite(&(node.var), sizeof(node.var), 1, fp);
            break;
        default:
            php_printf("UNKNOWN TYPE => %d\n", type);
    }
}

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

    fwrite(&(literals), sizeof(void*), 1, fp);
    for (i = 0; i < count; i++) {
        dump_zval(fp, literals[i]);
    }
}

void dump_zval(FILE* fp, zval val)
{
    fwrite(&(val.u1), sizeof(val.u1), 1, fp);
    fwrite(&(val.u2), sizeof(val.u2), 1, fp);
    switch(Z_TYPE(val)) {
        case IS_NULL:
        case IS_TRUE:
        case IS_FALSE:
            break;
        case IS_LONG:
            fwrite(&(val.value.lval), sizeof(val.value.lval), 1, fp);
            break;
        case IS_DOUBLE:
            fwrite(&(val.value.dval), sizeof(val.value.dval), 1, fp);
            break;
        case IS_STRING:
            dump_zend_string(fp, val.value.str);
            break;
        default:
            php_printf("ZVAL type not implemented yet: %d\n.", Z_TYPE(val));
    }
}

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

    fwrite(&vars, sizeof(vars), 1, fp);
    for (i = 0; i < count; i++) {
        dump_zend_string(fp, vars[i]);
    }
}

void dump_zend_string(FILE* fp, zend_string* str)
{
    fwrite(&(str), sizeof(void*), 1, fp);
    if (str != NULL) {
        fwrite(&(str->len), sizeof(str->len), 1, fp);
        fwrite(str->val, sizeof(char), str->len, fp);
    }
}

void dump_class_entry(FILE* fp, zend_class_entry* ce)
{
    fwrite(&(ce), sizeof(void*), 1, fp);
    if (ce != NULL) {
        php_printf("NON-NULL class entry!");
    }
}

void dump_zend_function(FILE* fp, zend_function* func)
{
    fwrite(&(func), sizeof(void*), 1, fp);
    if (func != NULL) {
        php_printf("NON-NULL zend_function!\n");
    }
}

void dump_arg_info(FILE* fp, zend_arg_info* info)
{
    fwrite(&(info), sizeof(void*), 1, fp);
    if (info != NULL) {
        php_printf("NON-NULL zend_arg_info!\n");
    }
}

void dump_brk_cont_array(FILE* fp, zend_brk_cont_element* array, int count)
{
    int i;

    fwrite(&(array), sizeof(void*), 1, fp);
    for (i = 0; i < count; i++) {
        dump_brk_cont_element(fp, array[i]);
    }
}

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

void dump_try_catch_array(FILE* fp, zend_try_catch_element* array, int count)
{
    int i;

    fwrite(&(array), sizeof(void*), 1, fp);
    for (i = 0; i < count; i++) {
        dump_try_catch_element(fp, array[i]);
    }
}

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

void dump_hashtable(FILE* fp, HashTable* table)
{
    fwrite(&(table), sizeof(void*), 1, fp);
    if (table != NULL) {
        php_printf("dump_hashtable NOT IMPLEMENTED yet.\n");
    }
}

void dump_runtime_cache(FILE* fp, void** cache, int count)
{
    fwrite(&(cache), sizeof(void*), 1, fp);
    if (cache != NULL) {
        php_printf("dump_runtime_cache NOT DONE: %d.\n", count);
    }
}

intptr_t handler_offset(const void* handler)
{
    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 ((intptr_t)handler) - handlers_base_address;
}