//
// immer: immutable data structures for C++
// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
//
// This software is distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
//

extern "C" {
#include <Python.h>
#include <structmember.h>
}

#include <immer/vector.hpp>
#include <immer/algorithm.hpp>
#include <immer/refcount/unsafe_refcount_policy.hpp>

#include <iostream>

namespace {

struct heap_t
{
    template <typename ...Tags>
    static void* allocate(std::size_t size, Tags...)
    {
        return PyMem_Malloc(size);
    }

    template <typename ...Tags>
    static void deallocate(std::size_t, void* obj, Tags...)
    {
        PyMem_Free(obj);
    }
};

struct object_t
{
    struct wrap_t {};
    struct adopt_t {};

    PyObject* ptr_ = nullptr;

    object_t() = delete;
    ~object_t() { Py_XDECREF(ptr_); }

    explicit object_t(PyObject* p, wrap_t)  : ptr_{p} {}
    explicit object_t(PyObject* p, adopt_t) : ptr_{p}
    {
        assert(p);
        Py_INCREF(p);
    }

    static object_t wrap(PyObject* p)  { return object_t{p, wrap_t{}}; }
    static object_t adopt(PyObject* p) { return object_t{p, adopt_t{}}; }

    object_t(const object_t& o) : ptr_(o.ptr_) { Py_INCREF(ptr_); }
    object_t(object_t&& o) { std::swap(ptr_, o.ptr_); }

    object_t& operator=(const object_t& o)
    {
        Py_XINCREF(o.ptr_);
        Py_XDECREF(ptr_);
        ptr_ = o.ptr_;
        return *this;
    }
    object_t& operator=(object_t&& o)
    {
        std::swap(ptr_, o.ptr_);
        return *this;
    }

    PyObject* release()
    {
        auto p = ptr_;
        ptr_ = nullptr;
        return p;
    }

    PyObject* get() const { return ptr_; }
};

using memory_t = immer::memory_policy<
    immer::unsafe_free_list_heap_policy<heap_t>,
    immer::unsafe_refcount_policy>;

using vector_impl_t = immer::vector<object_t, memory_t>;

struct vector_t
{
    PyObject_HEAD
    vector_impl_t impl;
    PyObject*     in_weakreflist;

    static PyTypeObject type;
};

vector_t* empty_vector = nullptr;

vector_t* make_vector()
{
    auto* v = PyObject_GC_New(vector_t, &vector_t::type);
    new (&v->impl) vector_impl_t{};
    v->in_weakreflist = nullptr;
    PyObject_GC_Track((PyObject*)v);
    return v;
}

vector_t* make_vector(vector_impl_t&& impl)
{
    auto v = PyObject_GC_New(vector_t, &vector_t::type);
    new (&v->impl) vector_impl_t{std::move(impl)};
    v->in_weakreflist = nullptr;
    PyObject_GC_Track((PyObject*)v);
    return v;
}

auto todo()
{
    PyErr_SetString(PyExc_RuntimeError, "immer: todo!");
    return nullptr;
}

void vector_dealloc(vector_t* self)
{
    if (self->in_weakreflist != nullptr)
        PyObject_ClearWeakRefs((PyObject*)self);

    PyObject_GC_UnTrack((PyObject*)self);
    Py_TRASHCAN_SAFE_BEGIN(self);

    self->impl.~vector_impl_t();

    PyObject_GC_Del(self);
    Py_TRASHCAN_SAFE_END(self);
}

PyObject* vector_to_list(vector_t* self)
{
    auto list = PyList_New(self->impl.size());
    auto idx  = 0;
    immer::for_each(self->impl, [&] (auto&& obj) {
            auto o = obj.get();
            Py_INCREF(o);
            PyList_SET_ITEM(list, idx, o);
            ++idx;
        });
    return list;
}

PyObject* vector_repr(vector_t *self)
{
    auto list = vector_to_list(self);
    auto list_repr = PyObject_Repr(list);
    Py_DECREF(list);

    if (!list_repr) return nullptr;

#if PY_MAJOR_VERSION >= 3
    auto s = PyUnicode_FromFormat("%s%U%s", "immer.vector(", list_repr, ")");
    Py_DECREF(list_repr);
#else
    auto s = PyString_FromString("immer.vector(");
    PyString_ConcatAndDel(&s, list_repr);
    PyString_ConcatAndDel(&s, PyString_FromString(")"));
#endif
    return s;
}

Py_ssize_t vector_len(vector_t* self)
{
    return self->impl.size();
}

PyObject* vector_extend(vector_t* self, PyObject* iterable)
{
    return todo();
}

vector_t* vector_append(vector_t* self, PyObject *obj)
{
    assert(obj != nullptr);
    return make_vector(self->impl.push_back(object_t::adopt(obj)));
}

vector_t* vector_set(vector_t* self, PyObject* args)
{
    PyObject* obj = nullptr;
    Py_ssize_t pos;
    // the n parses for size, the O parses for a Python object
    if(!PyArg_ParseTuple(args, "nO", &pos, &obj)) {
        return nullptr;
    }
    if (pos < 0)
        pos += self->impl.size();
    if (pos < 0 || pos > (Py_ssize_t)self->impl.size()) {
        PyErr_Format(PyExc_IndexError, "Index out of range: %zi", pos);
        return nullptr;
    }
    return make_vector(self->impl.set(pos, object_t::adopt(obj)));
}

PyObject* vector_new(PyTypeObject* subtype, PyObject *args, PyObject *kwds)
{
    Py_INCREF(empty_vector);
    return (PyObject*)empty_vector;
}

long vector_hash(vector_t* self)
{
    todo();
    return 0;
}

PyObject* vector_get_item(vector_t* self, Py_ssize_t pos)
{
    if (pos < 0)
        pos += self->impl.size();
    if (pos < 0 || pos >= (Py_ssize_t)self->impl.size()) {
        PyErr_Format(PyExc_IndexError, "Index out of range: %zi", pos);
        return nullptr;
    }
    auto r = self->impl[pos];
    return r.release();
}

PyObject* vector_subscript(vector_t* self, PyObject* item)
{
    if (PyIndex_Check(item)) {
        auto i = PyNumber_AsSsize_t(item, PyExc_IndexError);
        if (i == -1 && PyErr_Occurred())
            return nullptr;
        return vector_get_item(self, i);
    } else if (PySlice_Check(item)) {
        return todo();
    } else {
        PyErr_Format(PyExc_TypeError,
                     "vector indices must be integers, not %.200s",
                     Py_TYPE(item)->tp_name);
        return nullptr;
    }
}

PyObject* vector_repeat(vector_t* self, Py_ssize_t n)
{
    return todo();
}

int vector_traverse(vector_t* self, visitproc visit, void* arg)
{
    auto result = 0;
    immer::all_of(self->impl, [&] (auto&& o) {
            return 0 == (result = [&] {
                Py_VISIT(o.get());
                return 0;
            }());
        });
    return result;
}

PyObject* vector_richcompare(PyObject* v, PyObject* w, int op)
{
    return todo();
}

PyObject* vector_iter(PyObject* self)
{
    return todo();
}

PyMethodDef vector_methods[] =
{
    {"append",      (PyCFunction)vector_append, METH_O, "Appends an element"},
    {"set",         (PyCFunction)vector_set, METH_VARARGS, "Inserts an element at the specified position"},
    {"extend",      (PyCFunction)vector_extend, METH_O|METH_COEXIST, "Extend"},
    {"tolist",      (PyCFunction)vector_to_list, METH_NOARGS, "Convert to list"},
    {0}
};

PyMemberDef vector_members[] =
{
    {0}  /* sentinel */
};

PySequenceMethods vector_sequence_methods =
{
    (lenfunc)vector_len,             /* sq_length */
    (binaryfunc)vector_extend,       /* sq_concat */
    (ssizeargfunc)vector_repeat,     /* sq_repeat */
    (ssizeargfunc)vector_get_item,   /* sq_item */
    0,                               /* sq_slice */
    0,                               /* sq_ass_item */
    0,                               /* sq_ass_slice */
    0,                               /* sq_contains */
    0,                               /* sq_inplace_concat */
    0,                               /* sq_inplace_repeat */
};

PyMappingMethods vector_mapping_methods =
{
    (lenfunc)vector_len,
    (binaryfunc)vector_subscript,
    0
};

PyTypeObject vector_t::type =
{
    PyVarObject_HEAD_INIT(NULL, 0)
    "immer.Vector",                             /* tp_name        */
    sizeof(vector_t),                           /* tp_basicsize   */
    0,		                                /* tp_itemsize    */
    (destructor)vector_dealloc,                 /* tp_dealloc     */
    0,                                          /* tp_print       */
    0,                                          /* tp_getattr     */
    0,                                          /* tp_setattr     */
    0,                                          /* tp_compare     */
    (reprfunc)vector_repr,                      /* tp_repr        */
    0,                                          /* tp_as_number   */
    &vector_sequence_methods,                   /* tp_as_sequence */
    &vector_mapping_methods,                    /* tp_as_mapping  */
    (hashfunc)vector_hash,                      /* tp_hash        */
    0,                                          /* tp_call        */
    0,                                          /* tp_str         */
    0,                                          /* tp_getattro    */
    0,                                          /* tp_setattro    */
    0,                                          /* tp_as_buffer   */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags       */
    "",                                         /* tp_doc         */
    (traverseproc)vector_traverse,              /* tp_traverse       */
    0,                                          /* tp_clear          */
    vector_richcompare,                         /* tp_richcompare    */
    offsetof(vector_t, in_weakreflist),         /* tp_weaklistoffset */
    vector_iter,                                /* tp_iter           */
    0,                                          /* tp_iternext       */
    vector_methods,                             /* tp_methods        */
    vector_members,                             /* tp_members        */
    0,                                          /* tp_getset         */
    0,                                          /* tp_base           */
    0,                                          /* tp_dict           */
    0,                                          /* tp_descr_get      */
    0,                                          /* tp_descr_set      */
    0,                                          /* tp_dictoffset     */
    0,                                          /* tp_init           */
    0,                                          /* tp_alloc */
    vector_new,                                 /* tp_new   */
};

#if PY_MAJOR_VERSION >= 3
struct PyModuleDef module_def =
{
    PyModuleDef_HEAD_INIT,
    "immer_python_module", /* m_name */
    "",                  /* m_doc */
    -1,                  /* m_size */
    /module_methods,     /* m_methods */
    0,                   /* m_reload */
    0,                   /* m_traverse */
    0,                   /* m_clear */
    0,                   /* m_free */
};
#endif

PyMethodDef module_methods[] = {
    {0, 0, 0, 0}
};

PyObject* module_init()
{
    if (PyType_Ready(&vector_t::type) < 0)
        return nullptr;

#if PY_MAJOR_VERSION >= 3
    auto m = PyModule_Create(&module_def);
#else
    auto m = Py_InitModule3("immer_python_module", module_methods, "");
#endif
    if (!m)
        return nullptr;

    if (!empty_vector)
        empty_vector = make_vector();

    Py_INCREF(&vector_t::type);
    PyModule_AddObject(m, "Vector", (PyObject*) &vector_t::type);
    return m;
}

} // anonymous namespace

extern "C" {
#if PY_MAJOR_VERSION >= 3
PyMODINIT_FUNC PyInit_immer_python_module()
{
    return module_init();
}
#else
PyMODINIT_FUNC initimmer_python_module()
{
    module_init();
}
#endif
}