#include "ext/standard/php_var.h"
#include "ext/standard/php_smart_str.h"

PHP_METHOD(ArrayBuffer, serialize)
{
    buffer_object *intern;
    smart_str buf = {0};
    php_serialize_data_t var_hash;
    zval zv, *zv_ptr = &zv;

    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    intern = zend_object_store_get_object(getThis() TSRMLS_CC);
    if (!intern->buffer) {
        return;
    }

    PHP_VAR_SERIALIZE_INIT(var_hash);

    INIT_PZVAL(zv_ptr);

    /* バッファを文字列としてシリアライズする */
    ZVAL_STRINGL(zv_ptr, (char *) intern->buffer, (int) intern->length, 0);
    php_var_serialize(&buf, &zv_ptr, &var_hash TSRMLS_CC);

    /* プロパティを配列としてシリアライズする */
    Z_ARRVAL_P(zv_ptr) = zend_std_get_properties(getThis() TSRMLS_CC);
    Z_TYPE_P(zv_ptr) = IS_ARRAY;
    php_var_serialize(&buf, &zv_ptr, &var_hash TSRMLS_CC);

    PHP_VAR_SERIALIZE_DESTROY(var_hash);

    if (buf.c) {
        RETURN_STRINGL(buf.c, buf.len, 0);
    }
}

typedef struct {
    char *c;
    size_t len;
    size_t a;
} smart_str;

PHP_METHOD(ArrayBuffer, unserialize)
{
    buffer_object *intern;
    char *str;
    int str_len;
    php_unserialize_data_t var_hash;
    const unsigned char *p, *max;
    zval zv, *zv_ptr = &zv;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
        return;
    }

    intern = zend_object_store_get_object(getThis() TSRMLS_CC);

    if (intern->buffer) {
        zend_throw_exception(
            NULL, "Cannot call unserialize() on an already constructed object", 0 TSRMLS_CC
        );
        return;
    }

    PHP_VAR_UNSERIALIZE_INIT(var_hash);

    p = (unsigned char *) str;
    max = (unsigned char *) str + str_len;

    INIT_ZVAL(zv);
    if (!php_var_unserialize(&zv_ptr, &p, max, &var_hash TSRMLS_CC)
        || Z_TYPE_P(zv_ptr) != IS_STRING || Z_STRLEN_P(zv_ptr) == 0) {
        zend_throw_exception(NULL, "Could not unserialize buffer", 0 TSRMLS_CC);
        goto exit;
    }

    intern->buffer = Z_STRVAL_P(zv_ptr);
    intern->length = Z_STRLEN_P(zv_ptr);

    INIT_ZVAL(zv);
    if (!php_var_unserialize(&zv_ptr, &p, max, &var_hash TSRMLS_CC)
        || Z_TYPE_P(zv_ptr) != IS_ARRAY) {
        zend_throw_exception(NULL, "Could not unserialize properties", 0 TSRMLS_CC);
        goto exit;
    }

    if (zend_hash_num_elements(Z_ARRVAL_P(zv_ptr)) != 0) {
        zend_hash_copy(
            zend_std_get_properties(getThis() TSRMLS_CC), Z_ARRVAL_P(zv_ptr),
            (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *)
        );
    }

exit:
    zval_dtor(zv_ptr);
    PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
}

static HashTable *array_buffer_view_get_properties(zval *obj TSRMLS_DC)
{
    buffer_view_object *intern = zend_object_store_get_object(obj TSRMLS_CC);
    HashTable *ht = zend_std_get_properties(obj TSRMLS_CC);
    zval *zv;

    if (!intern->buffer_zval) {
        return ht;
    }

    Z_ADDREF_P(intern->buffer_zval);
    zend_hash_update(ht, "buffer", sizeof("buffer"), &intern->buffer_zval, sizeof(zval *), NULL);

    MAKE_STD_ZVAL(zv);
    ZVAL_LONG(zv, intern->offset);
    zend_hash_update(ht, "offset", sizeof("offset"), &zv, sizeof(zval *), NULL);

    MAKE_STD_ZVAL(zv);
    ZVAL_LONG(zv, intern->length);
    zend_hash_update(ht, "length", sizeof("length"), &zv, sizeof(zval *), NULL);

    return ht;
}

PHP_FUNCTION(array_buffer_view_wakeup)
{
    buffer_view_object *intern;
    HashTable *props;
    zval **buffer_zv, **offset_zv, **length_zv;

    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    intern = zend_object_store_get_object(getThis() TSRMLS_CC);

    if (intern->buffer_zval) {
        zend_throw_exception(
            NULL, "Cannot call __wakeup() on an already constructed object", 0 TSRMLS_CC
        );
        return;
    }

    props = zend_std_get_properties(getThis() TSRMLS_CC);

    if (zend_hash_find(props, "buffer", sizeof("buffer"), (void **) &buffer_zv) == SUCCESS
     && zend_hash_find(props, "offset", sizeof("offset"), (void **) &offset_zv) == SUCCESS
     && zend_hash_find(props, "length", sizeof("length"), (void **) &length_zv) == SUCCESS
     && Z_TYPE_PP(buffer_zv) == IS_OBJECT
     && Z_TYPE_PP(offset_zv) == IS_LONG && Z_LVAL_PP(offset_zv) >= 0
     && Z_TYPE_PP(length_zv) == IS_LONG && Z_LVAL_PP(length_zv) > 0
     && instanceof_function(Z_OBJCE_PP(buffer_zv), array_buffer_ce TSRMLS_CC)
    ) {
        buffer_object *buffer_intern = zend_object_store_get_object(*buffer_zv TSRMLS_CC);
        size_t offset = Z_LVAL_PP(offset_zv), length = Z_LVAL_PP(length_zv);
        size_t bytes_per_element = buffer_view_get_bytes_per_element(intern);
        size_t max_length = (buffer_intern->length - offset) / bytes_per_element;

        if (offset < buffer_intern->length && length <= max_length) {
            Z_ADDREF_PP(buffer_zv);
            intern->buffer_zval = *buffer_zv;

            intern->offset = offset;
            intern->length = length;

            intern->buf.as_int8 = buffer_intern->buffer;
            intern->buf.as_int8 += offset;

            return;
        }
    }

    zend_throw_exception(
        NULL, "Invalid serialization data", 0 TSRMLS_CC
    );
}

PHP_METHOD(SomeClass, __wakeup)
{
    if (zend_parse_parameters_none() == FAILURE) {
        return;
    }

    zend_throw_exception(NULL, "Unserialization of SomeClass is not allowed", 0 TSRMLS_CC);
}