#include "Python.h"

#include "structmember.h"

#include "hw/hw.h"

#include "sysemu.h"

#include "devtree.h"

#include "qemu-char.h"

#include "display_state.h"

#include "hw/gui.h"

#include "hw/fb_render_engine.h"

#include "qemu-timer.h"

static void qemu_py_die(void)

{

    PyErr_Print();

    exit(1);

}

#define qemu_py_assert(x) do { if (!(x)) { qemu_py_die(); } } while (0)

static void qemu_py_load_module(const char *name)

{

    PyObject *module;

    module = PyImport_ImportModule(name);

    if (!module)

        qemu_py_die();

}

static int64_t qemu_py_int64_from_pynum(PyObject *ob)

{

    if (PyInt_Check(ob))

        return PyInt_AsLong(ob);

    return PyLong_AsLongLong(ob);

}

static uint64_t qemu_py_uint64_from_pynum(PyObject *ob)

{

    if (PyInt_Check(ob))

        return PyInt_AsUnsignedLongMask(ob);

    return PyLong_AsUnsignedLongLongMask(ob);

}

typedef struct {

    PyObject_HEAD

    PyObject *size;

    PyObject *readl;

    PyObject *writel;

} qemu_py_ioregion;

static void qemu_py_ioregion_dealloc(qemu_py_ioregion *self)

{

    Py_CLEAR(self->size);

    Py_CLEAR(self->readl);

    Py_CLEAR(self->writel);

    self->ob_type->tp_free((PyObject*)self);

}

static int qemu_py_ioregion_init(qemu_py_ioregion *self, PyObject *args,

                                 PyObject *kwds)

{

    static char *kwlist[] = {"size", "readl", "writel", NULL};

    PyObject *obsize;

    PyObject *readl;

    PyObject *writel;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO", kwlist,

                                     &obsize, &readl, &writel))

        return -1; 

    Py_INCREF(obsize);

    self->size = obsize;

    Py_INCREF(readl);

    self->readl = readl;

    Py_INCREF(writel);

    self->writel = writel;

    return 0;

}

static PyMemberDef qemu_py_ioregion_members[] = {

    {"size", T_OBJECT, offsetof(qemu_py_ioregion, size), 0,

     "size"},

    {"readl", T_OBJECT, offsetof(qemu_py_ioregion, readl), 0,

     "32-bit read"},

    {"writel", T_OBJECT, offsetof(qemu_py_ioregion, writel), 0,

     "32-bit write"},

    {NULL}  /* Sentinel */

};

static PyTypeObject qemu_py_ioregionType = {

    PyObject_HEAD_INIT(NULL)

    0,                                    /* ob_size */

    "qemu.ioregion",                      /* tp_name */

    sizeof(qemu_py_ioregion),             /* tp_basicsize */

    0,                                    /* tp_itemsize */

    (destructor)qemu_py_ioregion_dealloc, /* tp_dealloc */

    0,                                    /* tp_print */

    0,                                    /* tp_getattr */

    0,                                    /* tp_setattr */

    0,                                    /* tp_compare */

    0,                                    /* tp_repr */

    0,                                    /* tp_as_number */

    0,                                    /* tp_as_sequence */

    0,                                    /* tp_as_mapping */

    0,                                    /* tp_hash  */

    0,                                    /* tp_call */

    0,                                    /* tp_str */

    0,                                    /* tp_getattro */

    0,                                    /* tp_setattro */

    0,                                    /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT,                   /* tp_flags */

    "QEMU IORegion",                      /* tp_doc */

    0,                                    /* tp_traverse */

    0,                                    /* tp_clear */

    0,		                          /* tp_richcompare */

    0,		                          /* tp_weaklistoffset */

    0,		                          /* tp_iter */

    0,		                          /* tp_iternext */

    0,                                    /* tp_methods */

    qemu_py_ioregion_members,             /* tp_members */

    0,                                    /* tp_getset */

    0,                                    /* tp_base */

    0,                                    /* tp_dict */

    0,                                    /* tp_descr_get */

    0,                                    /* tp_descr_set */

    0,                                    /* tp_dictoffset */

    (initproc)qemu_py_ioregion_init,      /* tp_init */

    0,                                    /* tp_alloc */

    0,                                    /* tp_new */

};

typedef struct {

    PyObject_HEAD

    QEMUFile *f;

} qemu_py_file;

static void qemu_py_file_dealloc(qemu_py_file *self)

{

    self->f = NULL;

    self->ob_type->tp_free((PyObject*)self);

}

static int qemu_py_file_init(qemu_py_file *self, PyObject *args,

                             PyObject *kwds)

{

    static char *kwlist[] = {"f", NULL};

    PyObject *obdata;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obdata))

        return -1; 

    self->f = PyCObject_AsVoidPtr(obdata);

    if (PyErr_Occurred())

        return -1;

    return 0;

}

static PyObject *qemu_py_file_get_u32(qemu_py_file *self, PyObject *args)

{

    uint32_t val;

    if (self->f) {

        val = qemu_get_be32(self->f);

        return PyLong_FromUnsignedLong(val);

    }

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_put_u32(qemu_py_file *self,

                                      PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"value", NULL};

    PyObject *obval;

    uint32_t val;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obval))

        return NULL;

    val = qemu_py_uint64_from_pynum(obval);

    if (PyErr_Occurred())

        return NULL;

    if (self->f)

        qemu_put_be32(self->f, val);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_get_u64(qemu_py_file *self, PyObject *args)

{

    uint64_t val;

    if (self->f) {

        val = qemu_get_be64(self->f);

        return PyLong_FromUnsignedLongLong(val);

    }

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_get_s64(qemu_py_file *self, PyObject *args)

{

    int64_t val;

    if (self->f) {

        val = qemu_get_be64(self->f);

        return PyLong_FromLongLong(val);

    }

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_put_u64(qemu_py_file *self,

                                      PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"value", NULL};

    PyObject *obval;

    uint64_t val;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obval))

        return NULL;

    val = qemu_py_uint64_from_pynum(obval);

    if (PyErr_Occurred())

        return NULL;

    if (self->f)

        qemu_put_be64(self->f, val);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_file_put_s64(qemu_py_file *self,

                                      PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"value", NULL};

    PyObject *obval;

    int64_t val;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &obval))

        return NULL;

    val = qemu_py_int64_from_pynum(obval);

    if (PyErr_Occurred())

        return NULL;

    if (self->f)

        qemu_put_be64(self->f, val);

    Py_RETURN_NONE;

}

static PyMethodDef qemu_py_file_methods[] = {

    {"get_u32", (PyCFunction)qemu_py_file_get_u32, METH_NOARGS,

     "Read unsigned 32-bit value"},

    {"put_u32", (PyCFunction)qemu_py_file_put_u32, METH_VARARGS|METH_KEYWORDS,

     "Write unsigned 32-bit value"},

    {"get_u64", (PyCFunction)qemu_py_file_get_u64, METH_NOARGS,

     "Read unsigned 64-bit value"},

    {"put_u64", (PyCFunction)qemu_py_file_put_u64, METH_VARARGS|METH_KEYWORDS,

     "Write unsigned 64-bit value"},

    {"get_s64", (PyCFunction)qemu_py_file_get_s64, METH_NOARGS,

     "Read signed 64-bit value"},

    {"put_s64", (PyCFunction)qemu_py_file_put_s64, METH_VARARGS|METH_KEYWORDS,

     "Write signed 64-bit value"},

    {NULL}  /* Sentinel */

};

static PyTypeObject qemu_py_fileType = {

    PyObject_HEAD_INIT(NULL)

    0,                                    /* ob_size */

    "qemu.file",                          /* tp_name */

    sizeof(qemu_py_file),                 /* tp_basicsize */

    0,                                    /* tp_itemsize */

    (destructor)qemu_py_file_dealloc,     /* tp_dealloc */

    0,                                    /* tp_print */

    0,                                    /* tp_getattr */

    0,                                    /* tp_setattr */

    0,                                    /* tp_compare */

    0,                                    /* tp_repr */

    0,                                    /* tp_as_number */

    0,                                    /* tp_as_sequence */

    0,                                    /* tp_as_mapping */

    0,                                    /* tp_hash  */

    0,                                    /* tp_call */

    0,                                    /* tp_str */

    0,                                    /* tp_getattro */

    0,                                    /* tp_setattro */

    0,                                    /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT,                   /* tp_flags */

    "QEMU File Object",                   /* tp_doc */

    0,                                    /* tp_traverse */

    0,                                    /* tp_clear */

    0,		                          /* tp_richcompare */

    0,		                          /* tp_weaklistoffset */

    0,		                          /* tp_iter */

    0,		                          /* tp_iternext */

    qemu_py_file_methods,                 /* tp_methods */

    0,                                    /* tp_members */

    0,                                    /* tp_getset */

    0,                                    /* tp_base */

    0,                                    /* tp_dict */

    0,                                    /* tp_descr_get */

    0,                                    /* tp_descr_set */

    0,                                    /* tp_dictoffset */

    (initproc)qemu_py_file_init,          /* tp_init */

    0,                                    /* tp_alloc */

    0,                                    /* tp_new */

};

typedef struct {

    PyObject_HEAD

    ptimer_state *ptimer;

} qemu_py_ptimer;

static void qemu_py_ptimer_dealloc(qemu_py_ptimer *self)

{

    self->ptimer = NULL;

    self->ob_type->tp_free((PyObject*)self);

}

static void qemu_py_ptimer_tick(void *opaque)

{

    PyObject *fn = opaque;

    PyObject *obval;

    obval = PyObject_CallFunctionObjArgs(fn, NULL);

    qemu_py_assert(obval);

    Py_DECREF(obval);

}

static int qemu_py_ptimer_init(qemu_py_ptimer *self, PyObject *args,

                               PyObject *kwds)

{

    static char *kwlist[] = {"tick", "freq", NULL};

    PyObject *tick;

    PyObject *obfreq = NULL;

    uint64_t freq;

    QEMUBH *bh;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", kwlist,

                                     &tick, &obfreq))

        return -1; 

    if (!PyCallable_Check(tick)) {

        PyErr_SetString(PyExc_TypeError, "tick handler must be callable");

        return -1;

    }

    if (obfreq) {

        freq = qemu_py_uint64_from_pynum(obfreq);

        if (PyErr_Occurred())

            return -1;

    } else {

        freq = 0;

    }

    Py_INCREF(tick);

    bh = qemu_bh_new(qemu_py_ptimer_tick, tick);

    self->ptimer = ptimer_init(bh);

    if (freq)

        ptimer_set_freq(self->ptimer, freq);

    return 0;

}

static PyObject *qemu_py_ptimer_run(qemu_py_ptimer *self,

                                    PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"oneshot", NULL};

    int oneshot;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &oneshot))

        return NULL;

    ptimer_run(self->ptimer, oneshot != 0);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_stop(qemu_py_ptimer *self, PyObject *args)

{

    ptimer_stop(self->ptimer);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_set_limit(qemu_py_ptimer *self,

                                          PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"limit", "reload", NULL};

    PyObject *oblimit;

    uint64_t limit;

    int reload;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oi", kwlist, &oblimit,

                                     &reload))

        return NULL;

    limit = qemu_py_uint64_from_pynum(oblimit);

    if (PyErr_Occurred())

        return NULL;

    ptimer_set_limit(self->ptimer, limit, reload != 0);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_get(qemu_py_ptimer *self,

                                    PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"f", NULL};

    qemu_py_file *f;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist,

                                     &qemu_py_fileType, &f))

        return NULL;

    qemu_get_ptimer(f->f, self->ptimer);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_put(qemu_py_ptimer *self,

                                    PyObject *args, PyObject *kwds)

{

    static char *kwlist[] = {"f", NULL};

    qemu_py_file *f;

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist,

                                     &qemu_py_fileType, &f))

        return NULL;

    qemu_put_ptimer(f->f, self->ptimer);

    Py_RETURN_NONE;

}

static PyObject *qemu_py_ptimer_get_count(qemu_py_ptimer *self, void *closure)

{

    return PyLong_FromUnsignedLongLong(ptimer_get_count(self->ptimer));

}

static int qemu_py_ptimer_set_count(qemu_py_ptimer *self, PyObject *obval,

                                    void *closure)

{

    uint64_t val;

    if (obval == NULL) {

        PyErr_SetString(PyExc_TypeError, "Cannot delete ptimer count");

        return -1;

    }

    val = qemu_py_uint64_from_pynum(obval);

    if (PyErr_Occurred())

        return -1;

    ptimer_set_count(self->ptimer, val);

    return 0;

}

static PyGetSetDef qemu_py_ptimer_getseters [] = {

    {"count", (getter)qemu_py_ptimer_get_count,

     (setter)qemu_py_ptimer_set_count,

     "current counter value", NULL},

    {NULL}  /* Sentinel */

};

static PyMethodDef qemu_py_ptimer_methods[] = {

    {"run", (PyCFunction)qemu_py_ptimer_run, METH_VARARGS|METH_KEYWORDS,

     "Start timer"},

    {"stop", (PyCFunction)qemu_py_ptimer_stop, METH_NOARGS,

     "Stop timer"},

    {"set_limit", (PyCFunction)qemu_py_ptimer_set_limit,

     METH_VARARGS|METH_KEYWORDS,

     "Set reload value"},

    {"get", (PyCFunction)qemu_py_ptimer_get, METH_VARARGS|METH_KEYWORDS,

     "Restore state"},

    {"put", (PyCFunction)qemu_py_ptimer_put, METH_VARARGS|METH_KEYWORDS,

     "Save state"},

    {NULL}  /* Sentinel */

};

static PyTypeObject qemu_py_ptimerType = {

    PyObject_HEAD_INIT(NULL)

    0,                                    /* ob_size */

    "qemu.ptimer",                        /* tp_name */

    sizeof(qemu_py_ptimer),               /* tp_basicsize */

    0,                                    /* tp_itemsize */

    (destructor)qemu_py_ptimer_dealloc,   /* tp_dealloc */

    0,                                    /* tp_print */

    0,                                    /* tp_getattr */

    0,                                    /* tp_setattr */

    0,                                    /* tp_compare */

    0,                                    /* tp_repr */

    0,                                    /* tp_as_number */

    0,                                    /* tp_as_sequence */

    0,                                    /* tp_as_mapping */

    0,                                    /* tp_hash  */

    0,                                    /* tp_call */

    0,                                    /* tp_str */

    0,                                    /* tp_getattro */

    0,                                    /* tp_setattro */

    0,                                    /* tp_as_buffer */

    Py_TPFLAGS_DEFAULT,                   /* tp_flags */

    "QEMU Periodic Timer",                /* tp_doc */

    0,                                    /* tp_traverse */

    0,                                    /* tp_clear */

    0,		                          /* tp_richcompare */

    0,		                          /* tp_weaklistoffset */

    0,		                          /* tp_iter */

    0,		                          /* tp_iternext */

    qemu_py_ptimer_methods,               /* tp_methods */

    0,                                    /* tp_members */

    qemu_py_ptimer_getseters,             /* tp_getset */

    0,                                    /* tp_base */

    0,                                    /* tp_dict */

    0,                                    /* tp_descr_get */

    0,                                    /* tp_descr_set */

    0,                                    /* tp_dictoffset */

    (initproc)qemu_py_ptimer_init,        /* tp_init */

    0,                                    /* tp_alloc */

    0,                                    /* tp_new */

};

typedef struct {

    PyObject_HEAD

    render_data *rdata;

} qemu_py_palette;

static void qemu_py_palette_dealloc(qemu_py_palette *self)

{

    self->rdata = NULL;

    self->ob_type->tp_free((PyObject*)self);