/*

 * manifest.c - manifest type that does on-demand parsing.

 *

 * Copyright 2015, Google Inc.

 *

 * This software may be used and distributed according to the terms of

 * the GNU General Public License, incorporated herein by reference.

 */

#include <Python.h>

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include "charencode.h"

#include "util.h"

#define DEFAULT_LINES 100000

typedef struct {

	char *start;

	Py_ssize_t len; /* length of line including terminal newline */

	char hash_suffix;

	bool from_malloc;

	bool deleted;

} line;

typedef struct {

	PyObject_HEAD

	PyObject *pydata;

	line *lines;

	int numlines; /* number of line entries */

	int livelines; /* number of non-deleted lines */

	int maxlines; /* allocated number of lines */

	bool dirty;

} lazymanifest;

#define MANIFEST_OOM -1

#define MANIFEST_NOT_SORTED -2

#define MANIFEST_MALFORMED -3

/* get the length of the path for a line */

static size_t pathlen(line *l)

{

	return strlen(l->start);

}

/* get the node value of a single line */

static PyObject *nodeof(line *l)

{

	char *s = l->start;

	ssize_t llen = pathlen(l);

	PyObject *hash = unhexlify(s + llen + 1, 40);

	if (!hash) {

		return NULL;

	}

	if (l->hash_suffix != '\0') {

		char newhash[21];

		memcpy(newhash, PyBytes_AsString(hash), 20);

		Py_DECREF(hash);

		newhash[20] = l->hash_suffix;

		hash = PyBytes_FromStringAndSize(newhash, 21);

	}

	return hash;

}

/* get the node hash and flags of a line as a tuple */

static PyObject *hashflags(line *l)

{

	char *s = l->start;

	size_t plen = pathlen(l);

	PyObject *hash = nodeof(l);

	/* 40 for hash, 1 for null byte, 1 for newline */

	size_t hplen = plen + 42;

	Py_ssize_t flen = l->len - hplen;

	PyObject *flags;

	PyObject *tup;

	if (!hash)

		return NULL;

	flags = PyBytes_FromStringAndSize(s + hplen - 1, flen);

	if (!flags) {

		Py_DECREF(hash);

		return NULL;

	}

	tup = PyTuple_Pack(2, hash, flags);

	Py_DECREF(flags);

	Py_DECREF(hash);

	return tup;

}

/* if we're about to run out of space in the line index, add more */

static bool realloc_if_full(lazymanifest *self)

{

	if (self->numlines == self->maxlines) {

		self->maxlines *= 2;

		self->lines = realloc(self->lines, self->maxlines * sizeof(line));

	}

	return !!self->lines;

}

/*

 * Find the line boundaries in the manifest that 'data' points to and store

 * information about each line in 'self'.

 */

static int find_lines(lazymanifest *self, char *data, Py_ssize_t len)

{

	char *prev = NULL;

	while (len > 0) {

		line *l;

		char *next = memchr(data, '\n', len);

		if (!next) {

			return MANIFEST_MALFORMED;

		}

		next++; /* advance past newline */

		if (!realloc_if_full(self)) {

			return MANIFEST_OOM; /* no memory */

		}

		if (prev && strcmp(prev, data) > -1) {

			/* This data isn't sorted, so we have to abort. */

			return MANIFEST_NOT_SORTED;

		}

		l = self->lines + ((self->numlines)++);

		l->start = data;

		l->len = next - data;

		l->hash_suffix = '\0';

		l->from_malloc = false;

		l->deleted = false;

		len = len - l->len;

		prev = data;

		data = next;

	}

	self->livelines = self->numlines;

	return 0;

}

static void lazymanifest_init_early(lazymanifest *self)

{

	self->pydata = NULL;

	self->lines = NULL;

	self->numlines = 0;

	self->maxlines = 0;

}

static int lazymanifest_init(lazymanifest *self, PyObject *args)

{

	char *data;

	Py_ssize_t len;

	int err, ret;

	PyObject *pydata;

	lazymanifest_init_early(self);

	if (!PyArg_ParseTuple(args, "S", &pydata)) {

		return -1;

	}

	err = PyBytes_AsStringAndSize(pydata, &data, &len);

	self->dirty = false;

	if (err == -1)

		return -1;

	self->pydata = pydata;

	Py_INCREF(self->pydata);

	Py_BEGIN_ALLOW_THREADS

	self->lines = malloc(DEFAULT_LINES * sizeof(line));

	self->maxlines = DEFAULT_LINES;

	self->numlines = 0;

	if (!self->lines)

		ret = MANIFEST_OOM;

	else

		ret = find_lines(self, data, len);

	Py_END_ALLOW_THREADS

	switch (ret) {

	case 0:

		break;

	case MANIFEST_OOM:

		PyErr_NoMemory();

		break;

	case MANIFEST_NOT_SORTED:

		PyErr_Format(PyExc_ValueError,

			     "Manifest lines not in sorted order.");

		break;

	case MANIFEST_MALFORMED:

		PyErr_Format(PyExc_ValueError,

			     "Manifest did not end in a newline.");

		break;

	default:

		PyErr_Format(PyExc_ValueError,

			     "Unknown problem parsing manifest.");

	}

	return ret == 0 ? 0 : -1;

}

static void lazymanifest_dealloc(lazymanifest *self)

{

	/* free any extra lines we had to allocate */

	int i;

	for (i = 0; self->lines && (i < self->numlines); i++) {

		if (self->lines[i].from_malloc) {

			free(self->lines[i].start);

		}

	}

	free(self->lines);

	self->lines = NULL;

	if (self->pydata) {

		Py_DECREF(self->pydata);

		self->pydata = NULL;

	}

	PyObject_Del(self);

}

/* iteration support */

typedef struct {

	PyObject_HEAD lazymanifest *m;

	Py_ssize_t pos;

} lmIter;

static void lmiter_dealloc(PyObject *o)

{

	lmIter *self = (lmIter *)o;

	Py_DECREF(self->m);

	PyObject_Del(self);

}

static line *lmiter_nextline(lmIter *self)

{

	do {

		self->pos++;

		if (self->pos >= self->m->numlines) {

			return NULL;

		}

		/* skip over deleted manifest entries */

	} while (self->m->lines[self->pos].deleted);

	return self->m->lines + self->pos;

}

static PyObject *lmiter_iterentriesnext(PyObject *o)

{

	size_t pl;

	line *l;

	Py_ssize_t consumed;

	PyObject *ret = NULL, *path = NULL, *hash = NULL, *flags = NULL;

	l = lmiter_nextline((lmIter *)o);

	if (!l) {

		goto done;

	}

	pl = pathlen(l);

	path = PyBytes_FromStringAndSize(l->start, pl);

	hash = nodeof(l);

	consumed = pl + 41;

	flags = PyBytes_FromStringAndSize(l->start + consumed,

					   l->len - consumed - 1);

	if (!path || !hash || !flags) {

		goto done;

	}

	ret = PyTuple_Pack(3, path, hash, flags);

done:

	Py_XDECREF(path);

	Py_XDECREF(hash);

	Py_XDECREF(flags);

	return ret;

}

#ifdef IS_PY3K

#define LAZYMANIFESTENTRIESITERATOR_TPFLAGS Py_TPFLAGS_DEFAULT

#else

#define LAZYMANIFESTENTRIESITERATOR_TPFLAGS Py_TPFLAGS_DEFAULT \

	| Py_TPFLAGS_HAVE_ITER

#endif

static PyTypeObject lazymanifestEntriesIterator = {

	PyVarObject_HEAD_INIT(NULL, 0) /* header */

	"parsers.lazymanifest.entriesiterator", /*tp_name */

	sizeof(lmIter),                  /*tp_basicsize */

	0,                               /*tp_itemsize */

	lmiter_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 */

	LAZYMANIFESTENTRIESITERATOR_TPFLAGS, /* tp_flags */

	"Iterator for 3-tuples in a lazymanifest.",  /* tp_doc */

	0,                               /* tp_traverse */

	0,                               /* tp_clear */

	0,                               /* tp_richcompare */

	0,                               /* tp_weaklistoffset */

	PyObject_SelfIter,               /* tp_iter: __iter__() method */

	lmiter_iterentriesnext,          /* tp_iternext: next() method */

};

static PyObject *lmiter_iterkeysnext(PyObject *o)

{

	size_t pl;

	line *l = lmiter_nextline((lmIter *)o);

	if (!l) {

		return NULL;

	}

	pl = pathlen(l);

	return PyBytes_FromStringAndSize(l->start, pl);

}

#ifdef IS_PY3K

#define LAZYMANIFESTKEYSITERATOR_TPFLAGS Py_TPFLAGS_DEFAULT

#else

#define LAZYMANIFESTKEYSITERATOR_TPFLAGS Py_TPFLAGS_DEFAULT \

	| Py_TPFLAGS_HAVE_ITER

#endif

static PyTypeObject lazymanifestKeysIterator = {

	PyVarObject_HEAD_INIT(NULL, 0) /* header */

	"parsers.lazymanifest.keysiterator", /*tp_name */

	sizeof(lmIter),                  /*tp_basicsize */

	0,                               /*tp_itemsize */

	lmiter_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 */

	LAZYMANIFESTKEYSITERATOR_TPFLAGS, /* tp_flags */

	"Keys iterator for a lazymanifest.",  /* tp_doc */

	0,                               /* tp_traverse */

	0,                               /* tp_clear */

	0,                               /* tp_richcompare */

	0,                               /* tp_weaklistoffset */

	PyObject_SelfIter,               /* tp_iter: __iter__() method */

	lmiter_iterkeysnext,             /* tp_iternext: next() method */

};

static lazymanifest *lazymanifest_copy(lazymanifest *self);

static PyObject *lazymanifest_getentriesiter(lazymanifest *self)

{

	lmIter *i = NULL;

	lazymanifest *t = lazymanifest_copy(self);

	if (!t) {

		PyErr_NoMemory();

		return NULL;

	}

	i = PyObject_New(lmIter, &lazymanifestEntriesIterator);

	if (i) {

		i->m = t;

		i->pos = -1;

	} else {

		Py_DECREF(t);

		PyErr_NoMemory();

	}

	return (PyObject *)i;

}

static PyObject *lazymanifest_getkeysiter(lazymanifest *self)

{

	lmIter *i = NULL;

	lazymanifest *t = lazymanifest_copy(self);

	if (!t) {

		PyErr_NoMemory();

		return NULL;

	}

	i = PyObject_New(lmIter, &lazymanifestKeysIterator);

	if (i) {

		i->m = t;

		i->pos = -1;

	} else {

		Py_DECREF(t);

		PyErr_NoMemory();

	}

	return (PyObject *)i;

}

/* __getitem__ and __setitem__ support */

static Py_ssize_t lazymanifest_size(lazymanifest *self)

{

	return self->livelines;

}

static int linecmp(const void *left, const void *right)

{

	return strcmp(((const line *)left)->start,

		      ((const line *)right)->start);

}

static PyObject *lazymanifest_getitem(lazymanifest *self, PyObject *key)

{

	line needle;

	line *hit;

	if (!PyBytes_Check(key)) {