#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_jco.h"

// Определим тестовую функцию 
PHP_FUNCTION(hello_from_jco)
{
    // Второй параметр указывает, что мы хотим скопировать строку в памяти.
    RETURN_STRING("JCO ENABLED! YEY!", 1);
}

// Дадим PHP знать о нашей функции, указав ее в таблице функций модуля.
const zend_function_entry jco_functions[] = {
    PHP_FE(hello_from_jco,  NULL)
    PHP_FE_END
};

// Определим функцию, которую php будет вызывать при подключении нашего расширения
PHP_MINIT_FUNCTION(jco_init)
{
    return SUCCESS;
}


zend_module_entry jco_module_entry = {
    STANDARD_MODULE_HEADER,
    "jco", // название асширения
    jco_functions,
    PHP_MINIT(jco_init),
    NULL, // MSHUTDOWN
    NULL, // RINIT
    NULL, // RSHUTDOWN
    NULL, // MINFO
    "0.1", //версия расширения
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_JCO
ZEND_GET_MODULE(jco)
#endif

#include "php.h"
#include "jco_darray.h"

zend_class_entry *jco_darray_ce;

PHP_METHOD(jco_darray, sayHello)
{
    RETURN_STRING("Hello from darray!", 1);
}

const zend_function_entry jco_darray_functions[] = {
    // имя класса, имя функции, arginfo, флаги
    PHP_ME(jco_darray, sayHello, NULL, ZEND_ACC_PUBLIC)
    PHP_FE_END
};

void jco_darray_init(TSRMLS_D)
{
    zend_class_entry tmp_ce;
    INIT_CLASS_ENTRY(tmp_ce, "JCO\\DArray", jco_darray_functions);

    jco_darray_ce = zend_register_internal_class(&tmp_ce TSRMLS_CC);

    return;
}

#ifndef PHP_JCO_DS_DARRAY_H
#define PHP_JCO_DS_DARRAY_H 1

#include "php.h"

typedef  struct jco_ds_darray {
    size_t count; // количество неNULLевых элементов
    size_t length; // текущий размер массива
    size_t min_length; // минимальный размер массива
    size_t capacity; // мощность - на сколько будет увеличиться размер
    void *elements; // массив елементов (zval)
} jco_ds_darray;

jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity);
void jco_ds_darray_destroy(jco_ds_darray *array);

#define jco_ds_darray_length(array) ((array)->length)
#define jco_ds_darray_min_length(array) ((array)->min_length)
#define jco_ds_darray_capacity(array) ((array)->capacity)
#define jco_ds_darray_count(array) ((array)->count)
#define jco_ds_darray_first(array) ((zval *)(array)->elements)

#endif

#include "ds/darray.h"
#include "php.h"

jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity) {
    jco_ds_darray *array = emalloc(sizeof(jco_ds_darray));
    if (!array) {
        return NULL;
    }

    array->count = 0;
    array->length = 0;
    array->min_length = size;
    array->capacity = capacity;
    array->elements = NULL;


    return array;
}


void jco_ds_darray_destroy(jco_ds_darray *array) {
    if (!array) {
        return;
    }

    efree(array);
}

zend_object_handlers jco_darray_handlers;

typedef struct jco_darray {
    zend_object std;
    jco_ds_darray *array;
} jco_darray;

static void jco_darray_free_object_storage(jco_darray *intern TSRMLS_DC)
{
    zend_object_std_dtor(&intern->std TSRMLS_CC);

    if (intern->array) {
        jco_ds_darray_destroy(intern->array);
    }

    efree(intern);
}

zend_object_value jco_darray_create_object(zend_class_entry *class_type TSRMLS_DC) {
    zend_object_value retval;

    jco_darray *intern = emalloc(sizeof(jco_darray));
    memset(intern, 0, sizeof(jco_darray));

    //Инициализирует объект: указавает ссылку на класс и обнуляет прочие поля
    zend_object_std_init(&intern->std, class_type TSRMLS_CC);
    //Копируем свойства класса в объект
    object_properties_init(&intern->std, class_type);

    // добавляет объект в хранилище объектов (object_store)
    retval.handle = zend_objects_store_put(
        intern,
        (zend_objects_store_dtor_t) zend_objects_destroy_object, // стандартный деструктор объекта
        (zend_objects_free_object_storage_t) jco_darray_free_object_storage, //наша функция бля освобождения памяти объекта
        NULL // функция копирования, нам не нужна
        TSRMLS_CC
    );

    //указываем ссылку на структуру с функциями-обаботчиками для объектов
    retval.handlers = &jco_darray_handlers;

    return retval;
}

PHP_METHOD(jco_darray, __construct)
{
    jco_darray *intern;
    long size = 0;
    long capacity = 0;

    zend_error_handling error_handling;

    //Заменим обработчик ошибок так, чтобы при ошибке получения аргументов конструктора было выброшено исключение
    zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);

    //третий параметр указывает на типы переменных (l - long), последующие - указатели на переменные
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &size, &capacity) == FAILURE) {
        zend_restore_error_handling(&error_handling TSRMLS_CC);
        return;
    }

    // Восстанавливаем стандартный обработчик ошибок
    zend_restore_error_handling(&error_handling TSRMLS_CC);

    if (size <= 0) {
        zend_throw_exception(NULL, "Array size must be positive", 0 TSRMLS_CC);
        return;
    }

    if (capacity < 0) {
        zend_throw_exception(NULL, "Array capacity must be positive or 0", 0 TSRMLS_CC);
        return;
    }

    // получаем объект по handle
    intern = zend_object_store_get_object(getThis() TSRMLS_CC);

    intern->array = jco_ds_darray_create((size_t)size, (size_t)capacity);
    if (!intern->array) {
        zend_throw_exception(NULL, "Failed to allocate array", 0 TSRMLS_CC);
    }

    return;
}

    #include "ds/darray.h"
#include "php.h"

#define ELEM_SIZE (sizeof(zval))

// Увеличиваем память под элементы массива. 
// Если указан index, то выделяем память кратно capacity настолько,
// чтобы было место для index-го элемента
static inline int _jco_ds_darray_expand(jco_ds_darray *array, size_t index) {
    if (array && array->capacity > 0) {
        size_t capacity = array->capacity;
        size_t max_elements = array->length;
        size_t expand_count;
        if (index) {
            expand_count = ((index + 1) / capacity) * capacity + capacity;
        } else {
            expand_count = (max_elements + capacity);
        }

        zval *elements;
        if (max_elements == 0 && !array->elements) {
            elements = (zval *)emalloc(ELEM_SIZE * expand_count);
        } else {
            elements = (zval *)erealloc((void *)array->elements, ELEM_SIZE * expand_count);
        }

        if (elements) {
            zval *ptr = (elements + max_elements);
            memset(ptr, 0, array->capacity * ELEM_SIZE);

            array->length = expand_count;
            array->elements = elements;

            return 1;
        }

        return 0;
    }

    return 0;
}


jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity) {
    jco_ds_darray *array = emalloc(sizeof(jco_ds_darray));
    if (!array) {
        return NULL;
    }

    array->length = 0;
    array->min_length = size;
    array->capacity = size;
    array->count = 0;
    array->elements = NULL;

    if (size > 0 && !_jco_ds_darray_expand(array, 0)) {
        efree(array);

        return NULL;
    }

    array->length = size;
    array->capacity = capacity;

    return array;
}


void jco_ds_darray_destroy(jco_ds_darray *array) {
    if (!array) {
        return;
    }

    if (array->length > 0) {
        zval *elem = (zval *)array->elements;
        while (array->length--) {
            if (elem != NULL && Z_REFCOUNT_P(elem) > 0) {
                zval_dtor(elem);
            }
            elem++;
        }
    }

    if (array->elements) {
        efree(array->elements);
    }

    efree(array);
}

jco_ds_darray *jco_ds_darray_clone(jco_ds_darray *array) {
    if (!array) {
        return NULL;
    }

    jco_ds_darray *new_array = emalloc(sizeof(jco_ds_darray));
    if (!new_array) {
        return NULL;
    }

    new_array->count = array->count;
    new_array->length = array->length;
    new_array->min_length = array->min_length;
    new_array->capacity = array->capacity;
    new_array->elements = (zval *)emalloc(ELEM_SIZE * array->length);
    if (!new_array->elements) {
        efree(new_array);

        return NULL;
    }

    memcpy(new_array->elements, array->elements, ELEM_SIZE * array->length);
    //memcpy скопировал нам только zval`ы, но они указывают на одни те же значения
    //Чтобы это исправить нужно пройтись по элементам функцией zval_copy_ctor
    size_t index;
    for (index = 0; index < array->length; index++) {
        zval *elem = (zval *)new_array->elements + index;
        if (elem != NULL && Z_REFCOUNT_P(elem) > 0) {
            zval_copy_ctor(elem);
        }
    }



    return new_array;

}


zval *jco_ds_darray_get(jco_ds_darray *array, size_t index) {
    if (!array || array->length < (index + 1)) {
        return NULL;
    }

    zval *elem = (zval *)(array->elements) + index;
    if (!elem || Z_TYPE_P(elem) == IS_NULL) {
        return NULL;
    }

    //На всякий случай убедимся, что is_ref__gc = 0
    Z_UNSET_ISREF_P(elem);
    return elem;
}


void jco_ds_darray_unset(jco_ds_darray *array, size_t index) {
    if (!array || array->length < (index + 1)) {
        return;
    }

    zval *elem = (zval *)array->elements + index;
    if (elem != NULL && Z_REFCOUNT_P(elem) > 0) {
        if (Z_TYPE_P(elem) != IS_NULL) {
            array->count--;
        }

        zval_dtor(elem);
        *elem = (zval) {0};
    }

}


zval *jco_ds_darray_set(jco_ds_darray *array, size_t index, zval *value) {
    if (!array) {
        return;
    }

    if ((index + 1) > array->length) {
        if (array->capacity == 0) {
            return NULL;
        }

        if (!_jco_ds_darray_expand(array, index)) {
            return NULL;
        }
    }
    zval *elem = (zval *)array->elements + index;
    int prev_is_not_null = 0;
    if (Z_REFCOUNT_P(elem) > 0 && Z_TYPE_P(elem)) {
        zval_dtor(elem);
        prev_is_not_null = 1;
    }

    elem->value = value->value;
    elem->type  = value->type;
    elem->refcount__gc = 1;
    elem->is_ref__gc = 0;
    zval_copy_ctor(elem);

    if (prev_is_not_null && Z_TYPE_P(elem) == IS_NULL) {
        array->count--;
    }
    else if (!prev_is_not_null && Z_TYPE_P(elem) != IS_NULL) {
        array->count++;
    }


    return elem;
}

    PHP_METHOD(jco_darray, count)
{
    jco_darray *intern;
    long count;

    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    count = (long)jco_ds_darray_count(intern->array);

    ZVAL_LONG(return_value, count);
}

PHP_METHOD(jco_darray, length)
{
    jco_darray *intern;
    long length;

    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    length = (long) jco_ds_darray_length(intern->array);

    ZVAL_LONG(return_value, length);
}

PHP_METHOD(jco_darray, offsetSet)
{
    jco_darray *intern;
    zval *val;
    long index;


    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &index, &val) == FAILURE) {
        zend_throw_exception(NULL, "Failed to parse arguments", 0 TSRMLS_CC);
        return;
    }

    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    jco_ds_darray_set(intern->array, (size_t)index, val);

}

PHP_METHOD(jco_darray, offsetUnset)
{
    jco_darray *intern;
    long index;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {
        zend_throw_exception(NULL, "Invalid index passed", 0 TSRMLS_CC);
        return;
    }


    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    jco_ds_darray_unset(intern->array, (size_t)index);
}

PHP_METHOD(jco_darray, offsetGet)
{
    jco_darray *intern;
    long index;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {
        zend_throw_exception(NULL, "Invalid index passed", 0 TSRMLS_CC);
        return;
    }


    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    zval *val = jco_ds_darray_get(intern->array, (size_t)index);

    if (val) {
        //назначиние, источник, вызвать zval_copy_ctor, вызвать zval_ptr_dtor
        ZVAL_ZVAL(return_value, val, 1, 0);
    } else {
        ZVAL_NULL(return_value);
    }
}

PHP_METHOD(jco_darray, offsetExists)
{
    jco_darray *intern;
    long index;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {
        zend_throw_exception(NULL, "Invalid index passed", 0 TSRMLS_CC);
        return;
    }


    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    zval *val = jco_ds_darray_get(intern->array, (size_t)index);
    if (val) {
        ZVAL_TRUE(return_value);
    } else {
        ZVAL_FALSE(return_value);
    }
}

ZEND_BEGIN_ARG_INFO_EX(arginfo_jco_darray_offset, 0, 0, 1)
ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_jco_darray_offset_value, 0, 0, 2)
ZEND_ARG_INFO(0, offset)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()

const zend_function_entry jco_darray_functions[] = {
    PHP_ME(jco_darray, __construct, arginfo_construct, ZEND_ACC_PUBLIC)
    PHP_ME(jco_darray, offsetSet, arginfo_jco_darray_offset_value, ZEND_ACC_PUBLIC)
    PHP_ME(jco_darray, offsetGet, arginfo_jco_darray_offset, ZEND_ACC_PUBLIC)
    PHP_ME(jco_darray, offsetUnset, arginfo_jco_darray_offset, ZEND_ACC_PUBLIC)
    PHP_ME(jco_darray, offsetExists, arginfo_jco_darray_offset, ZEND_ACC_PUBLIC)
    PHP_ME(jco_darray, count, arginfo_void, ZEND_ACC_PUBLIC)
    PHP_ME(jco_darray, length, arginfo_void, ZEND_ACC_PUBLIC)
    PHP_FE_END
};

//Вспомогательная функция, которая приведет zval к long
static inline long zval_to_long(zval *zv) {
    if (Z_TYPE_P(zv) == IS_LONG) {
        return Z_LVAL_P(zv);
    } else {
        zval tmp = *zv;
        zval_copy_ctor(&tmp);
        convert_to_long(&tmp);
        return Z_LVAL(tmp);
    }
}

static zend_object_value jco_darray_clone(zval *object TSRMLS_DC) {
    jco_darray *old_object = zend_object_store_get_object(object TSRMLS_CC);

    zend_object_value new_object_val = jco_darray_create_object(Z_OBJCE_P(object) TSRMLS_CC);
    jco_darray *new_object = zend_object_store_get_object_by_handle(new_object_val.handle TSRMLS_CC);

    //Копируем свойства объекта
    zend_objects_clone_members(
        &new_object->std, new_object_val,
        &old_object->std, Z_OBJ_HANDLE_P(object) TSRMLS_CC
    );

    new_object->array = jco_ds_darray_clone(old_object->array);

    if (!new_object->array) {
        zend_throw_exception(NULL, "Failed to clone jco_darray", 0 TSRMLS_CC);
    }

    return new_object_val;
}

 
static zval *jco_darray_read_dimension(zval *object, zval *zv_offset, int type TSRMLS_DC) {
    jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);
    
    if (intern->std.ce->parent) {
        return zend_get_std_object_handlers()->read_dimension(object, zv_offset, type TSRMLS_CC);
    }

    if (!zv_offset) {
        zend_throw_exception(NULL, "Cannot append to a jco_darray", 0 TSRMLS_CC);
        return NULL;
    }

    long offset = zval_to_long(zv_offset);
    if (offset < 0 || offset > jco_ds_darray_length(intern->array)) {
        zend_throw_exception(NULL, "Offset out of range", 0 TSRMLS_CC);
        return NULL;
    }

    zval *return_value;
    zval *value = jco_ds_darray_get(intern->array, offset);

    if (value) {

        if (type != BP_VAR_R && type != BP_WAR_RW) {
            return_value = value;
            Z_SET_ISREF_P(return_value);
        } else {
            MAKE_STD_ZVAL(return_value);
            ZVAL_ZVAL(return_value, value, 1, 0);
            Z_DELREF_P(return_value);
        }
    } else {
        MAKE_STD_ZVAL(return_value);
        ZVAL_NULL(return_value);
        Z_DELREF_P(return_value);
    }

    return return_value;
}


static void jco_darray_write_dimension(zval *object, zval *zv_offset, zval *value TSRMLS_DC) {
    jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);

    if (intern->std.ce->parent) {
        return zend_get_std_object_handlers()->write_dimension(object, zv_offset, value TSRMLS_CC);
    }


    if (!zv_offset) {
        zend_throw_exception(NULL, "Cannot append to a jco_darray", 0 TSRMLS_CC);
    }

    long offset = zval_to_long(zv_offset);
    if (offset < 0) {
        zend_throw_exception(NULL, "Offset out of range", 0 TSRMLS_CC);
    }

    zval *saved_val = jco_ds_darray_set(intern->array, (size_t)offset, value);
    if (saved_val == NULL) {
        zend_throw_exception(NULL, "Error occured during dimension write", 0 TSRMLS_CC);
    }
}



static int jco_darray_has_dimension(zval *object, zval *zv_offset, int check_empty TSRMLS_DC) {
    jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);

    if (intern->std.ce->parent) {
        return zend_get_std_object_handlers()->has_dimension(object, zv_offset, check_empty TSRMLS_CC);
    }

    long offset = zval_to_long(zv_offset);
    if (offset < 0 || offset > jco_ds_darray_length(intern->array)) {
        return 0;
    }

    zval *value = jco_ds_darray_get(intern->array, offset);
    if (value == NULL) {
        return 0;
    }

    if (check_empty) {
        return zend_is_true(value);
    } else {
        return Z_TYPE_P(value) != IS_NULL;
    }

}

static void jco_darray_unset_dimension(zval *object, zval *zv_offset TSRMLS_DC) {
    jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);

    if (intern->std.ce->parent) {
        return zend_get_std_object_handlers()->unset_dimension(object, zv_offset TSRMLS_CC);
    }

    long offset = zval_to_long(zv_offset);
    if (offset < 0 || offset > jco_ds_darray_length(intern->array)) {
        zend_throw_exception(NULL, "Offset out of range", 0 TSRMLS_CC);
    }

    jco_ds_darray_unset(intern->array, offset);
}

int jco_darray_count_elements(zval *object, long *count TSRMLS_DC) {
    jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);

    if (intern->std.ce->parent) {
        return zend_get_std_object_handlers()->count_elements(object, count TSRMLS_CC);
    }

    if (intern && intern->array) {
        *count = (long)jco_ds_darray_count(intern->array);
        return SUCCESS;
    } else {
        *count = 0;
        return FAILURE;
    }
}

static void jco_darray_iterator_dtor(zend_object_iterator *intern TSRMLS_DC) {
    jco_darray_iterator_data *data = (jco_darray_iterator_data *)intern->data;

    if (data->current != NULL) {
        zval_ptr_dtor(&data->current);
    }

    zval_ptr_dtor((zval **)&data->object_zval);
    efree(data);
    efree(intern);
}

static int jco_darray_iterator_valid(zend_object_iterator *intern TSRMLS_DC) {
    jco_darray_iterator_data *data = (jco_darray_iterator_data *)intern->data;

    return jco_ds_darray_length(data->object->array) > data->offset ? SUCCESS : FAILURE;
}

//
static void jco_darray_iterator_get_current_data(zend_object_iterator *intern, zval ***data TSRMLS_DC) {
    jco_darray_iterator_data *iter_data = (jco_darray_iterator_data *)intern->data;

    if (iter_data->current != NULL) {
        zval_ptr_dtor(&iter_data->current);
        iter_data->current = NULL;
    }

    if (iter_data->offset < jco_ds_darray_length(iter_data->object->array)) {
        zval *value = jco_ds_darray_get(iter_data->object->array, iter_data->offset);
        if (value != NULL) {
            MAKE_STD_ZVAL(iter_data->current);
            ZVAL_ZVAL(iter_data->current, value, 1, 0);

            *data = &iter_data->current;
        } else {
            *data = NULL;
        }

    } else {
        *data = NULL;
    }
}


#if ZEND_MODULE_API_NO >= 20121212
// версии php 5.5+
static void jco_darray_iterator_get_current_key(zend_object_iterator *intern, zval *key TSRMLS_DC) {
    jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;
    ZVAL_LONG(key, data->offset);
}
#else
//В более ранних версиях строковые и численные ключи нужно отдавать в отдельных переменных
// и возвращать HASH_KEY_IS_STRING, HASH_KEY_IS_LONG или HASH_KEY_NON_EXISTANT
static int jco_darray_iterator_get_current_key(zend_object_iterator *intern, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC) {
    jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;

    *int_key = (ulong) data->offset;
    return HASH_KEY_IS_LONG;
}
#endif

static void jco_darray_iterator_move_forward(zend_object_iterator *intern TSRMLS_DC) {
    jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;

    data->offset++;
}

static void jco_darray_iterator_rewind(zend_object_iterator *intern TSRMLS_DC)
{
    jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;

    data->offset = 0;
    data->current = NULL;
}

static zend_object_iterator_funcs jco_darray_iterator_funcs = {
    jco_darray_iterator_dtor,
    jco_darray_iterator_valid,
    jco_darray_iterator_get_current_data,
    jco_darray_iterator_get_current_key,
    jco_darray_iterator_move_forward,
    jco_darray_iterator_rewind,
    NULL
};