/*
 * adcli
 *
 * Copyright (C) 2013 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301 USA
 *
 * Author: Stef Walter <stefw@redhat.com>
 */

#include "config.h"

#include "adattrs.h"
#include "adprivate.h"
#include "seq.h"

#include <assert.h>
#include <stdlib.h>

adcli_attrs *
adcli_attrs_new (void)
{
	adcli_attrs *attrs;

	attrs = calloc (1, sizeof (adcli_attrs));
	return_val_if_fail (attrs != NULL, NULL);

	return attrs;
}

int
adcli_attrs_have (adcli_attrs *attrs,
                  const char *name)
{
	LDAPMod match = { -1, (char *)name, };
	LDAPMod *mod;

	return_val_if_fail (attrs != NULL, 0);
	return_val_if_fail (name != NULL, 0);

	mod = seq_lookup ((void **)attrs->mods, &attrs->len,
	                  &match, _adcli_ldap_mod_compar);

	return mod ? 1 : 0;
}

static void
attrs_insert1 (adcli_attrs *attrs,
               int mod_op,
               const char *name,
               const char *value)
{
	LDAPMod match = { 0, (char *)name, };
	LDAPMod *mod;

	mod = seq_lookup ((void **)attrs->mods, &attrs->len,
	                  &match, _adcli_ldap_mod_compar);

	/* A new attribute */
	if (mod == NULL) {
		const char *values[] = { value, NULL };
		mod = _adcli_ldap_mod_new (mod_op, name, values);
		return_if_fail (mod != NULL);

		attrs->mods = (LDAPMod **)seq_insert ((void **)attrs->mods,
		                                      &attrs->len, mod,
		                                      _adcli_ldap_mod_compar,
		                                      _adcli_ldap_mod_free);

	/* Add a value */
	} else {
		return_if_fail (mod->mod_op == mod_op);
		mod->mod_vals.modv_strvals =
		     _adcli_strv_add (mod->mod_vals.modv_strvals,
		                      strdup (value), NULL);
	}
}

static void
attrs_insert (adcli_attrs *attrs,
              int mod_type,
              const char *name,
              const char **values)
{
	LDAPMod *mod;

	mod = _adcli_ldap_mod_new (mod_type, name, values);
	return_if_fail (mod != NULL);

	attrs->mods = (LDAPMod **)seq_insert ((void **)attrs->mods,
	                                      &attrs->len, mod,
	                                      _adcli_ldap_mod_compar,
	                                      _adcli_ldap_mod_free);
}

static void
attrs_insertv (adcli_attrs *attrs,
                   int mod_type,
                   const char *name,
                   const char *value,
                   va_list va)
{
	const char *fast[] = { value, NULL };
	char **values = NULL;
	int num = 0;

	fast[1] = va_arg(va, const char *);
	if (fast[1] == NULL) {
		attrs_insert (attrs, mod_type, name, fast);
		return;
	}

	values = seq_push (values, &num, (void *)fast[0]);
	values = seq_push (values, &num, (void *)fast[1]);

	while ((value = va_arg (va, const char *)) != NULL)
		values = seq_push (values, &num, (void *)value);

	attrs_insert (attrs, mod_type, name, (const char **)values);
	seq_free (values, NULL);
}

void
adcli_attrs_add1 (adcli_attrs *attrs,
                  const char *name,
                  const char *value)
{
	return_if_fail (attrs != NULL);
	return_if_fail (name != NULL);
	return_if_fail (value != NULL);

	attrs_insert1 (attrs, LDAP_MOD_ADD, name, value);
}

void
adcli_attrs_add (adcli_attrs *attrs,
                 const char *name,
                 const char *value,
                 ...)
{
	va_list va;

	return_if_fail (attrs != NULL);
	return_if_fail (name != NULL);
	return_if_fail (value != NULL);

	va_start (va, value);
	attrs_insertv (attrs, LDAP_MOD_ADD, name, value, va);
	va_end (va);
}


void
adcli_attrs_replace (adcli_attrs *attrs,
                     const char *name,
                     const char *value,
                     ...)
{
	va_list va;

	return_if_fail (attrs != NULL);
	return_if_fail (name != NULL);
	return_if_fail (value != NULL);

	va_start (va, value);
	attrs_insertv (attrs, LDAP_MOD_REPLACE, name, value, va);
	va_end (va);
}

void
adcli_attrs_delete1 (adcli_attrs *attrs,
                     const char *name,
                     const char *value)
{
	return_if_fail (attrs != NULL);
	return_if_fail (name != NULL);
	return_if_fail (value != NULL);

	attrs_insert1 (attrs, LDAP_MOD_DELETE, name, value);
}

void
adcli_attrs_delete (adcli_attrs *attrs,
                    const char *name,
                    const char *value,
                    ...)
{
	va_list va;

	return_if_fail (attrs != NULL);
	return_if_fail (name != NULL);
	return_if_fail (value != NULL);

	va_start (va, value);
	attrs_insertv (attrs, LDAP_MOD_DELETE, name, value, va);
	va_end (va);
}

void
adcli_attrs_free (adcli_attrs *attrs)
{
	if (!attrs)
		return;

	seq_free (attrs->mods, _adcli_ldap_mod_free);
	free (attrs);
}

#ifdef ATTRS_TESTS

#include "test.h"

static void
test_new_free (void)
{
	adcli_attrs *attrs;

	attrs = adcli_attrs_new ();
	assert (attrs != NULL);

	adcli_attrs_free (attrs);
}

static void
test_free_null (void)
{
	adcli_attrs_free (NULL);
}

static void
test_adda (void)
{
	adcli_attrs *attrs;

	attrs = adcli_attrs_new ();

	adcli_attrs_add (attrs, "blah", "value", "two", NULL);
	adcli_attrs_add1 (attrs, "blah", "three");

	adcli_attrs_add (attrs, "other", "wheee", NULL);

	assert_num_eq (attrs->len, 2);

	assert (attrs->mods[0]->mod_op == LDAP_MOD_ADD);
	assert_str_eq (attrs->mods[0]->mod_type, "blah");
	assert_num_eq (seq_count (attrs->mods[0]->mod_vals.modv_strvals), 3);
	assert_str_eq (attrs->mods[0]->mod_vals.modv_strvals[0], "value");
	assert_str_eq (attrs->mods[0]->mod_vals.modv_strvals[1], "two");
	assert_str_eq (attrs->mods[0]->mod_vals.modv_strvals[2], "three");
	assert (attrs->mods[0]->mod_vals.modv_strvals[3] == NULL);

	assert (attrs->mods[1]->mod_op == LDAP_MOD_ADD);
	assert_str_eq (attrs->mods[1]->mod_type, "other");
	assert_num_eq (seq_count (attrs->mods[1]->mod_vals.modv_strvals), 1);
	assert_str_eq (attrs->mods[1]->mod_vals.modv_strvals[0], "wheee");
	assert (attrs->mods[1]->mod_vals.modv_strvals[1] == NULL);

	adcli_attrs_free (attrs);
}

static void
test_replace (void)
{
	adcli_attrs *attrs;

	attrs = adcli_attrs_new ();

	adcli_attrs_add1 (attrs, "blah", "value");
	adcli_attrs_add1 (attrs, "blah", "two");

	adcli_attrs_replace (attrs, "blah", "new", NULL);

	adcli_attrs_add (attrs, "other", "wheee", NULL);

	assert_num_eq (attrs->len, 2);

	assert (attrs->mods[0]->mod_op == LDAP_MOD_REPLACE);
	assert_str_eq (attrs->mods[0]->mod_type, "blah");
	assert_num_eq (seq_count (attrs->mods[0]->mod_vals.modv_strvals), 1);
	assert_str_eq (attrs->mods[0]->mod_vals.modv_strvals[0], "new");
	assert (attrs->mods[0]->mod_vals.modv_strvals[1] == NULL);

	assert (attrs->mods[1]->mod_op == LDAP_MOD_ADD);
	assert_str_eq (attrs->mods[1]->mod_type, "other");
	assert_num_eq (seq_count (attrs->mods[1]->mod_vals.modv_strvals), 1);
	assert_str_eq (attrs->mods[1]->mod_vals.modv_strvals[0], "wheee");
	assert (attrs->mods[1]->mod_vals.modv_strvals[1] == NULL);

	adcli_attrs_free (attrs);
}

int
main (int argc,
      char *argv[])
{
	test_func (test_new_free, "/attrs/new_free");
	test_func (test_free_null, "/attrs/free_null");
	test_func (test_adda, "/attrs/add");
	test_func (test_replace, "/attrs/replace");
	return test_run (argc, argv);
}

#endif /* ATTRS_TESTS */