#include "../stdafx.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
#if defined(_WINDOWS) && !defined(_CYGWIN)
#include "wincompat.h"
#endif
#include "utils.h"
#include "plist.h"
#include "ptree.h"
#include "pdict-impl.h"

typedef struct pdict_ent pdict_ent_t;
typedef int (*pdict_walk_int_func_t)(pdict_ent_t *pde, void *arg);

static int _pdict_ent_add_persistent_change_listeners(pdict_t *pd,
    pdict_ent_t *pde);
static int _pdict_ent_add_persistent_change_listener(pdict_ent_t *pde,
    pdict_persistent_listener_t *pl);
static int _pdict_ent_remove_persistent_change_listener(pdict_ent_t *pde,
    pdict_persistent_listener_t *pl);
static void _pdict_ent_notify(pdict_ent_t *pde, int reason, const char *ov);
static int _pdict_ent_add_change_listener(pdict_ent_t *pde,
    pdl_notify_func_t notify, void *arg);
static int _pdict_walk_int(pdict_t *pd, pdict_walk_int_func_t w, void *arg);
static int _pdict_ent_remove_change_listener(pdict_ent_t *pde,
    pdl_notify_func_t notify, void *a);

pdict_t *
pdict_alloc(void)
{
	pdict_t *pd;

	if (!(pd = malloc(sizeof (*pd))))
		return 0;
	memset(pd, 0, sizeof (*pd));

	return pd;
}

static int
pdecmp(const void *sv, const void *dv)
{
	return strcmp(*(char **)sv, *(char **)dv);
}

static int
pdict_ent_remove_change_listeners_cb(const void *v, const void *v0, void *a)
{
	free((void *)v); v = NULL;
	return (1);
}

static int
pdict_ent_remove_change_listeners(pdict_ent_t *pde)
{
	plist_walk(pde->pde_listeners, pdict_ent_remove_change_listeners_cb, 0);
	plist_clear(&pde->pde_listeners);
	return 1;
}

static int
pdict_ent_listeners_copy_cb(const void *v, const void *v0, void *a)
{
	pdict_listener_t *pdl = (pdict_listener_t *)v;
	pdict_ent_t *pde_ent_copy = a;

	return _pdict_ent_add_change_listener(pde_ent_copy, pdl->pdl_notify, pdl->pdl_arg);
}

static void
_pdict_ent_listeners_copy(pdict_ent_t *pde, pdict_ent_t *pde_copy)
{
	plist_walk(pde->pde_listeners, pdict_ent_listeners_copy_cb, pde_copy);
}

/*
 * Sets or resets an entry to the dictionary, returning 0 on failure.
 */
int
pdict_add(pdict_t *pd, const char *k, const char *v, const char **ovp)
{
	pdict_ent_t *n;
	pdict_ent_t n_copy;
	const char *ov;

	if (!(k = strdup(k)))
		return 0;
	if (!(v = strdup(v))) {
		free((void *)k); k = NULL;
		return 0;
	}
	memset(&n_copy, 0, sizeof(pdict_ent_t));
	if (ptree_contains((void *)&k, pd->pd_ents, pdecmp, (void *)&n)) {
		free((void *)k); k = NULL;
		ov = n->pde_val;
		n->pde_val = v;

		if (ovp)
			*ovp = ov;
		else {
			free((void *)ov); ov = NULL;
		}
		
		//We copy n so that it's safe if it gets removed during a callback
		if(n->pde_listeners)
		{
			n_copy.pde_key = strdup(n->pde_key);
			n_copy.pde_val = strdup(n->pde_val);
			_pdict_ent_listeners_copy(n, &n_copy);
			_pdict_ent_notify(&n_copy, PDR_VALUE_CHANGED, ov);
			pdict_ent_remove_change_listeners(&n_copy);
			free((char *)n_copy.pde_key);
			free((char *)n_copy.pde_val);
		}
		return 1;
	}
	if (!(n = malloc(sizeof (*n)))) {
		free((void *)k); k = NULL;
		free((void *)v); v = NULL;
		return (0);
	}
	memset(n, 0, sizeof (*n));
	n->pde_key = k;
	n->pde_val = v;

	//Add dict listeners to the dict entry object
	if (!_pdict_ent_add_persistent_change_listeners(pd, n)) {
		free((void *)k); k = NULL;
		free((void *)v); v = NULL;
		free(n); n = NULL;
		return (0);
	}
	//Add the dict entry to the dict (replacing if there is a matching key).
	if (!ptree_replace(n, &pd->pd_ents, pdecmp, NULL)) {
		pdict_ent_remove_change_listeners(n);
		free((void *)k); k = NULL;
		free((void *)v); v = NULL;
		free(n); n = NULL;
		return (0);
	}
	//notify the listeners
	if(n->pde_listeners)
	{
		n_copy.pde_key = strdup(n->pde_key);
		n_copy.pde_val = strdup(n->pde_val);
		_pdict_ent_listeners_copy(n, &n_copy);
		_pdict_ent_notify(&n_copy, PDR_ENTRY_ADDED, n_copy.pde_val);
		pdict_ent_remove_change_listeners(&n_copy);
		free((char *)n_copy.pde_key);
		free((char *)n_copy.pde_val);
	}

	if (ovp)
		*ovp = NULL;

	return 1;
}

int
pdict_ent_remove(pdict_t *pd, const char *k, char **ovp)
{
	pdict_ent_t *n;

	pu_log(PUL_VERB, 0, "Removing in key pdict_ent_remove: %s", k);
	
	if (!ptree_remove((void *)&k, &pd->pd_ents, pdecmp, (void *)&n))
	{
		//pu_log(PUL_INFO, 0, "Failed to remove key in pdict_ent_remove: %s", k);
		return 0;
	}
	
	_pdict_ent_notify(n, PDR_ENTRY_REMOVING, n->pde_val);
	
	if (ovp)
		*ovp = (char *)n->pde_val;
	else {
		free((void *)n->pde_val);
	}
	free((void *)n->pde_key);
	pdict_ent_remove_change_listeners(n);
	free(n);
	return 1;
}

static int
pdict_ent_remove_persistent_change_listener_cb(const void *pl, const void *v,
    void *a)
{
	_pdict_ent_remove_persistent_change_listener((pdict_ent_t *)a,
	    (pdict_persistent_listener_t *)pl);
	return 1;
}

static int
pdict_ent_add_persistent_change_listener_cb(const void *lid, const void *pl,
    void *a)
{
	return _pdict_ent_add_persistent_change_listener((pdict_ent_t *)a,
	    (pdict_persistent_listener_t *)pl);
}

static int
_pdict_ent_add_persistent_change_listeners(pdict_t *pd, pdict_ent_t *pde)
{
	if (!plist_walk(pd->pd_persistent_listeners, pdict_ent_add_persistent_change_listener_cb, pde)) {
		plist_walk(pd->pd_persistent_listeners, pdict_ent_remove_persistent_change_listener_cb, pde);
		pu_log(PUL_WARN, 0, "Failed to add persistent change listener in _pdict_ent_add_persistent_change_listeners.");
		return 0;
	}
	return 1;
}

static int
pdict_ent_remove_persistent_change_listener_dcb(pdict_ent_t *pde, void *pl)
{
	return _pdict_ent_remove_persistent_change_listener(pde,
	    (pdict_persistent_listener_t *)pl);
}

static int
pdict_ent_add_persistent_change_listener_dcb(pdict_ent_t *pde, void *pl)
{
	return _pdict_ent_add_persistent_change_listener(pde,
	    (pdict_persistent_listener_t *)pl);
}

static int
_pdict_ent_add_persistent_change_listener(pdict_ent_t *pde,
    pdict_persistent_listener_t *pdpl)
{
	int res;

	if ((res = regexec(&pdpl->pdpl_regex, pde->pde_key, 0, NULL, 0)) != 0)
	{
		return res == REG_NOMATCH;
	}
	if (!_pdict_ent_add_change_listener(pde, pdpl->pdpl_l.pdl_notify, pdpl->pdpl_l.pdl_arg))
	{
		pu_log(PUL_WARN, 0, "Failed to add persistent change listener in _pdict_ent_add_persistent_change_listener.");
		return 0;
	}
	if (pdpl->pdpl_new)
		pdpl->pdpl_l.pdl_notify(pde->pde_key, pde->pde_val, PDR_CURRENT_VALUE, NULL, pdpl->pdpl_l.pdl_arg);
	return 1;
}

static int
_pdict_ent_remove_persistent_change_listener(pdict_ent_t *pde,
    pdict_persistent_listener_t *pl)
{
	_pdict_ent_remove_change_listener(pde, pl->pdpl_l.pdl_notify,
	    pl->pdpl_l.pdl_arg);
	return 1;
}

int
pdict_remove_persistent_change_listener(pdict_t *pd, int id)
{
	pdict_persistent_listener_t *pdpl;

	if (!plist_remove((void *)(size_t)id, &pd->pd_persistent_listeners, (void **)&pdpl) || !pdpl)
	{
		pu_log(PUL_WARN, 0, "Failed plist_remove in pdict_remove_persistent_change_listener.");
		return 0;
	}
	if (!_pdict_walk_int(pd, pdict_ent_remove_persistent_change_listener_dcb, pdpl))
	{
		pu_log(PUL_WARN, 0, "Failed _pdict_walk_int in pdict_remove_persistent_change_listener.");
		return 0;
	}
	regfree(&pdpl->pdpl_regex);
	free(pdpl); pdpl = NULL;
	return 1;
}

int
pdict_add_persistent_change_listener(pdict_t *pd, const char *kpat,
    pdl_notify_func_t notify, void *arg)
{
	pdict_persistent_listener_t *pl;
	static int lid = 1;

	if (!(pl = malloc(sizeof (*pl))))
		return 0;
	memset(pl, 0, sizeof (*pl));
	pl->pdpl_l.pdl_notify = notify;
	pl->pdpl_l.pdl_arg = arg;
	if (regcomp(&pl->pdpl_regex, kpat, REG_EXTENDED | REG_NOSUB) != 0) {
		// XXX todo: communicate error context is not libc
		free(pl); pl = NULL;
		pu_log(PUL_WARN, 0, "Failed regcomp in pdict_add_persistent_change_listener.");
		return 0;
	}

	plist_add((void *)(size_t)lid, pl, &pd->pd_persistent_listeners);

	pl->pdpl_new = 1;
	if (!_pdict_walk_int(pd,
	    pdict_ent_add_persistent_change_listener_dcb, pl)) {
		_pdict_walk_int(pd,
		    pdict_ent_remove_persistent_change_listener_dcb, pl);
		plist_remove((void *)(size_t)lid, &pd->pd_persistent_listeners, NULL);
		regfree(&pl->pdpl_regex);
		free(pl); pl = NULL;
		pu_log(PUL_WARN, 0, "Failed _pdict_walk_int in pdict_add_persistent_change_listener.");
		return 0;
	}
	pl->pdpl_new = 0;
	return lid++;
}

/*
 * Return whether a given key is in the dictionary.  If the given
 * entry pointer is non-NULL, set it to the entry.
 */
static int
_pdict_ent_lookup(pdict_t *pd, const char *k, pdict_ent_t **e)
{
	return ptree_contains((void *)&k, pd->pd_ents, pdecmp, (void **)e);
}

int
pdict_ent_lookup(pdict_t *pd, const char *k, const char **v)
{
	pdict_ent_t *pde;

	if (_pdict_ent_lookup(pd, k, &pde)) {
		if (v)
			*v = strdup(pde->pde_val);
		return 1;
	}
	return 0;
}

static int
pdict_ent_remove_change_listener_cb(const void *k, const void *v, void *a)
{
	pdict_listener_t *l = (pdict_listener_t *)k;
	void **arg = (void **)a;

	if (l->pdl_notify == (pdl_notify_func_t)arg[0] && l->pdl_arg == arg[1]) {
		arg[2] = l;
		return 0;
	}
	return 1;
}

static int
_pdict_ent_remove_change_listener(pdict_ent_t *pde, pdl_notify_func_t notify,
    void *a)
{
	void *arg[3];

	arg[0] = (void *)notify;
	arg[1] = a;
	arg[2] = NULL;
	plist_walk(pde->pde_listeners, pdict_ent_remove_change_listener_cb, arg);
	if (arg[2]) {
		plist_remove(arg[2], &pde->pde_listeners, NULL);
		free(arg[2]); arg[2] = NULL;
		return 1;
	}
	return 0;
}

static int
_pdict_ent_add_change_listener(pdict_ent_t *pde, pdl_notify_func_t notify,
    void *arg)
{
	pdict_listener_t *l;

	if (!(l = malloc(sizeof (*l))))
		return 0;
	memset(l, 0, sizeof (*l));
	l->pdl_notify = notify;
	l->pdl_arg = arg;
	if (!plist_add(l, 0, &pde->pde_listeners)) {
		free(l); l = NULL;
		pu_log(PUL_WARN, 0, "Failed plist_add in _pdict_ent_add_change_listener.");
		return 0;
	}

	return 1;
}

int
pdict_ent_add_change_listener(pdict_t *pd, const char *k,
    pdl_notify_func_t notify, void *arg)
{
	pdict_ent_t *pde;

	if (!_pdict_ent_lookup(pd, k, &pde))
		return 0;
	return _pdict_ent_add_change_listener(pde, notify, arg);
}

typedef struct {
	pdict_ent_t *penca_pde;
	pdict_reason_t penca_reason;
	const char *penca_ov;
} pdict_ent_notify_cb_args_t;

static int
pdict_ent_notify_cb(const void *v, const void *v0, void *a)
{
	pdict_listener_t *pdl = (pdict_listener_t *)v;
	pdict_ent_notify_cb_args_t *penca = a;

	pdl->pdl_notify(penca->penca_pde->pde_key, penca->penca_pde->pde_val,
	    penca->penca_reason, penca->penca_ov, pdl->pdl_arg);
	return 1;
}

static void
_pdict_ent_notify(pdict_ent_t *pde, int reason, const char *ov)
{
	pdict_ent_notify_cb_args_t penca = { pde, reason, ov };

	plist_walk(pde->pde_listeners, pdict_ent_notify_cb, &penca);
}

static ptree_walk_res_t
pdict_walk_int_cb(const void *v, int level, void *a, void *pwra)
{
	void **args = a;

	return ((pdict_walk_int_func_t)args[0])((pdict_ent_t *)v, args[1]);
}

static ptree_walk_res_t
pdict_walk_cb(const void *v, int level, void *a, void *pwra)
{
	pdict_ent_t *pde = (pdict_ent_t *)v;
	void **args = a;

	return ((pdict_walk_func_t)args[0])(pde->pde_key, pde->pde_val,
	    args[1]);
}

static int
_pdict_walk_int(pdict_t *pd, pdict_walk_int_func_t w, void *arg)
{
	void *args[2] = { (void *)w, arg };

	return ptree_walk(pd->pd_ents, PTREE_INORDER, pdict_walk_int_cb, pdecmp, args);
}

int
pdict_walk(pdict_t *pd, pdict_walk_func_t w, void *arg)
{
	void *args[2] = { (void *)w, arg };

	return ptree_walk(pd->pd_ents, PTREE_INORDER, pdict_walk_cb, NULL, args);
}

int
pdict_ent_remove_change_listener(pdict_t *pd, const char *k,
    pdl_notify_func_t nf, void *arg)
{
	pdict_ent_t *e;
	int res;

	if (!(res = _pdict_ent_lookup(pd, k, &e)))
		return 0;
	return _pdict_ent_remove_change_listener(e, nf, arg);
}

const char *
pdict_reason_str(pdict_reason_t r)
{
	switch (r) {
	case PDR_VALUE_CHANGED:
		return "changed";
	case PDR_ENTRY_ADDED:
		return "added";
	case PDR_ENTRY_REMOVING:
		return "removing";
	case PDR_CURRENT_VALUE:
		return "current";
	default:
		return "?";
	}
}

pdict_reason_t
pdict_reason_from_str(const char *s)
{
	if (strcmp(s, "changed") == 0)
		return PDR_VALUE_CHANGED;
	if (strcmp(s, "current") == 0)
		return PDR_CURRENT_VALUE;
	if (strcmp(s, "added") == 0)
		return PDR_ENTRY_ADDED;
	if (strcmp(s, "removing") == 0)
		return PDR_ENTRY_REMOVING;
	return 0;
}