/*

Copyright (c) 2013-2015, Facebook, Inc.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice,

   this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,

   this list of conditions and the following disclaimer in the documentation

   and/or other materials provided with the distribution.

 * Neither the name Facebook nor the names of its contributors may be used to

   endorse or promote products derived from this software without specific

   prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include <Python.h>

#include <bytesobject.h>

#ifdef _MSC_VER

#define inline __inline

#if _MSC_VER >= 1800

#include <stdint.h>

#else

// The compiler associated with Python 2.7 on Windows doesn't ship

// with stdint.h, so define the small subset that we use here.

typedef __int8 int8_t;

typedef __int16 int16_t;

typedef __int32 int32_t;

typedef __int64 int64_t;

typedef unsigned __int8 uint8_t;

typedef unsigned __int16 uint16_t;

typedef unsigned __int32 uint32_t;

typedef unsigned __int64 uint64_t;

#define UINT32_MAX 4294967295U

#endif

#endif

// clang-format off

/* Return the smallest size int that can store the value */

#define INT_SIZE(x) (((x) == ((int8_t)x))  ? 1 :    \

                     ((x) == ((int16_t)x)) ? 2 :    \

                     ((x) == ((int32_t)x)) ? 4 : 8)

#define BSER_ARRAY     0x00

#define BSER_OBJECT    0x01

#define BSER_BYTESTRING 0x02

#define BSER_INT8      0x03

#define BSER_INT16     0x04

#define BSER_INT32     0x05

#define BSER_INT64     0x06

#define BSER_REAL      0x07

#define BSER_TRUE      0x08

#define BSER_FALSE     0x09

#define BSER_NULL      0x0a

#define BSER_TEMPLATE  0x0b

#define BSER_SKIP      0x0c

#define BSER_UTF8STRING 0x0d

// clang-format on

// An immutable object representation of BSER_OBJECT.

// Rather than build a hash table, key -> value are obtained

// by walking the list of keys to determine the offset into

// the values array.  The assumption is that the number of

// array elements will be typically small (~6 for the top

// level query result and typically 3-5 for the file entries)

// so that the time overhead for this is small compared to

// using a proper hash table.  Even with this simplistic

// approach, this is still faster for the mercurial use case

// as it helps to eliminate creating N other objects to

// represent the stat information in the hgwatchman extension

// clang-format off

typedef struct {

  PyObject_HEAD

  PyObject *keys;   // tuple of field names

  PyObject *values; // tuple of values

} bserObject;

// clang-format on

static Py_ssize_t bserobj_tuple_length(PyObject* o) {

  bserObject* obj = (bserObject*)o;

  return PySequence_Length(obj->keys);

}

static PyObject* bserobj_tuple_item(PyObject* o, Py_ssize_t i) {

  bserObject* obj = (bserObject*)o;

  return PySequence_GetItem(obj->values, i);

}

// clang-format off

static PySequenceMethods bserobj_sq = {

  bserobj_tuple_length,      /* sq_length */

  0,                         /* sq_concat */

  0,                         /* sq_repeat */

  bserobj_tuple_item,        /* sq_item */

  0,                         /* sq_ass_item */

  0,                         /* sq_contains */

  0,                         /* sq_inplace_concat */

  0                          /* sq_inplace_repeat */

};

// clang-format on

static void bserobj_dealloc(PyObject* o) {

  bserObject* obj = (bserObject*)o;

  Py_CLEAR(obj->keys);

  Py_CLEAR(obj->values);

  PyObject_Del(o);

}

static PyObject* bserobj_getattrro(PyObject* o, PyObject* name) {

  bserObject* obj = (bserObject*)o;

  Py_ssize_t i, n;

  PyObject* name_bytes = NULL;

  PyObject* ret = NULL;

  if (PyIndex_Check(name)) {

    i = PyNumber_AsSsize_t(name, PyExc_IndexError);

    if (i == -1 && PyErr_Occurred()) {

      goto bail;

    }

      goto bail;

    }

  } else {

  }

  if (namestr == NULL) {

    goto bail;

  }

  // hack^Wfeature to allow mercurial to use "st_size" to reference "size"

  if (!strncmp(namestr, "st_", 3)) {

    namestr += 3;

  }

  n = PyTuple_GET_SIZE(obj->keys);

  for (i = 0; i < n; i++) {

    const char* item_name = NULL;

    PyObject* key = PyTuple_GET_ITEM(obj->keys, i);

    item_name = PyBytes_AsString(key);

    if (!strcmp(item_name, namestr)) {

      ret = PySequence_GetItem(obj->values, i);

      goto bail;

    }

  }

  PyErr_Format(

      PyExc_AttributeError, "bserobject has no attribute '%.400s'", namestr);

bail:

  Py_XDECREF(name_bytes);

  return ret;

}

// clang-format off

static PyMappingMethods bserobj_map = {

  bserobj_tuple_length,     /* mp_length */

  bserobj_getattrro,        /* mp_subscript */

  0                         /* mp_ass_subscript */

};

PyTypeObject bserObjectType = {

  PyVarObject_HEAD_INIT(NULL, 0)

  "bserobj_tuple",           /* tp_name */

  sizeof(bserObject),        /* tp_basicsize */

  0,                         /* tp_itemsize */

  bserobj_dealloc,           /* tp_dealloc */

  0,                         /* tp_print */

  0,                         /* tp_getattr */

  0,                         /* tp_setattr */

  0,                         /* tp_compare */

  0,                         /* tp_repr */

  0,                         /* tp_as_number */

  &bserobj_sq,               /* tp_as_sequence */

  &bserobj_map,              /* tp_as_mapping */

  0,                         /* tp_hash  */

  0,                         /* tp_call */

  0,                         /* tp_str */

  bserobj_getattrro,         /* tp_getattro */

  0,                         /* tp_setattro */

  0,                         /* tp_as_buffer */

  Py_TPFLAGS_DEFAULT,        /* tp_flags */

  "bserobj tuple",           /* tp_doc */

  0,                         /* tp_traverse */

  0,                         /* tp_clear */

  0,                         /* tp_richcompare */

  0,                         /* tp_weaklistoffset */

  0,                         /* tp_iter */

  0,                         /* tp_iternext */

  0,                         /* 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 */

  0,                         /* tp_init */

  0,                         /* tp_alloc */

  0,                         /* tp_new */

};

// clang-format on

typedef struct loads_ctx {

  int mutable;

  const char* value_encoding;

  const char* value_errors;

  uint32_t bser_version;

  uint32_t bser_capabilities;

} unser_ctx_t;

static PyObject*

bser_loads_recursive(const char** ptr, const char* end, const unser_ctx_t* ctx);

static const char bser_true = BSER_TRUE;

static const char bser_false = BSER_FALSE;

static const char bser_null = BSER_NULL;

static const char bser_bytestring_hdr = BSER_BYTESTRING;

static const char bser_array_hdr = BSER_ARRAY;

static const char bser_object_hdr = BSER_OBJECT;

static inline uint32_t next_power_2(uint32_t n) {

  n |= (n >> 16);

  n |= (n >> 8);

  n |= (n >> 4);

  n |= (n >> 2);

  n |= (n >> 1);

  return n + 1;

}

// A buffer we use for building up the serialized result

struct bser_buffer {

  char* buf;

  int wpos, allocd;

  uint32_t bser_version;

  uint32_t capabilities;

};

typedef struct bser_buffer bser_t;

static int bser_append(bser_t* bser, const char* data, uint32_t len) {

  int newlen = next_power_2(bser->wpos + len);

  if (newlen > bser->allocd) {

    char* nbuf = realloc(bser->buf, newlen);

    if (!nbuf) {

      return 0;

    }

    bser->buf = nbuf;

    bser->allocd = newlen;

  }

  memcpy(bser->buf + bser->wpos, data, len);

  bser->wpos += len;

  return 1;

}

static int bser_init(bser_t* bser, uint32_t version, uint32_t capabilities) {

  bser->allocd = 8192;

  bser->wpos = 0;

  bser->buf = malloc(bser->allocd);

  bser->bser_version = version;

  bser->capabilities = capabilities;

  if (!bser->buf) {

    return 0;

  }

// Leave room for the serialization header, which includes

// our overall length.  To make things simpler, we'll use an

// int32 for the header

#define EMPTY_HEADER "\x00\x01\x05\x00\x00\x00\x00"

// Version 2 also carries an integer indicating the capabilities. The

// capabilities integer comes before the PDU size.

#define EMPTY_HEADER_V2 "\x00\x02\x00\x00\x00\x00\x05\x00\x00\x00\x00"

  if (version == 2) {

    bser_append(bser, EMPTY_HEADER_V2, sizeof(EMPTY_HEADER_V2) - 1);

  } else {

    bser_append(bser, EMPTY_HEADER, sizeof(EMPTY_HEADER) - 1);

  }

  return 1;

}

static void bser_dtor(bser_t* bser) {

  free(bser->buf);

  bser->buf = NULL;

}

static int bser_long(bser_t* bser, int64_t val) {

  int8_t i8;

  int16_t i16;

  int32_t i32;

  int64_t i64;

  char sz;

  int size = INT_SIZE(val);

  char* iptr;

  switch (size) {

    case 1:

      sz = BSER_INT8;

      i8 = (int8_t)val;

      iptr = (char*)&i8;

      break;

    case 2:

      sz = BSER_INT16;

      i16 = (int16_t)val;

      iptr = (char*)&i16;

      break;

    case 4:

      sz = BSER_INT32;

      i32 = (int32_t)val;

      iptr = (char*)&i32;

      break;

    case 8:

      sz = BSER_INT64;

      i64 = (int64_t)val;

      iptr = (char*)&i64;

      break;

    default:

      PyErr_SetString(PyExc_RuntimeError, "Cannot represent this long value!?");

      return 0;

  }

  if (!bser_append(bser, &sz, sizeof(sz))) {

    return 0;

  }

  return bser_append(bser, iptr, size);

}

static int bser_bytestring(bser_t* bser, PyObject* sval) {

  char* buf = NULL;

  Py_ssize_t len;

  int res;

  PyObject* utf = NULL;

  if (PyUnicode_Check(sval)) {

    utf = PyUnicode_AsEncodedString(sval, "utf-8", "ignore");

    sval = utf;

  }

  res = PyBytes_AsStringAndSize(sval, &buf, &len);

  if (res == -1) {

    res = 0;

    goto out;

  }

  if (!bser_append(bser, &bser_bytestring_hdr, sizeof(bser_bytestring_hdr))) {

    res = 0;

    goto out;

  }

  if (!bser_long(bser, len)) {

    res = 0;

    goto out;

  }

  if (len > UINT32_MAX) {

    PyErr_Format(PyExc_ValueError, "string too big");

    res = 0;

    goto out;

  }

  res = bser_append(bser, buf, (uint32_t)len);

out:

  if (utf) {

    Py_DECREF(utf);

  }

  return res;

}

static int bser_recursive(bser_t* bser, PyObject* val) {

  if (PyBool_Check(val)) {

    if (val == Py_True) {

      return bser_append(bser, &bser_true, sizeof(bser_true));

    }

    return bser_append(bser, &bser_false, sizeof(bser_false));

  }

  if (val == Py_None) {

    return bser_append(bser, &bser_null, sizeof(bser_null));

  }

// Python 3 has one integer type.

#if PY_MAJOR_VERSION < 3

  if (PyInt_Check(val)) {

    return bser_long(bser, PyInt_AS_LONG(val));

  }