/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.

 */

#include <stdio.h>

#include <string.h>

#include <rad/adr.h>

#include <rad/adr_object.h>

#include <rad/rad_modapi.h>

#include "api_test-compat-cnew.h"

#define	TESTSTR1 "thing 1"

#define	TESTSTR2 "thing 2"

#define	TESTINT1 13579

#define	TESTINT2 24680

#define	TESTBOOL1 B_TRUE

#define	TESTBOOL2 B_FALSE

#define	ACCTNAME1 "John"

#define	ACCTNAME2 "Sam"

#define	ACCTNUM1 "John-C123"

#define	ACCTNUM2 "Sam-S456"

#define	ACCTPASS "secret"

#define	ACCTLOCN "Massachusetts"

#define	ACCTCHECK &e__AcctTypeEnum_checking

#define	ACCTBAL 5000

static conerr_t make_error(data_t *code, data_t **error);

static data_t *make_acct(const char *aname, const char *anum);

/*ARGSUSED*/

conerr_t

api_CompatTest_read_boolPropTest(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	/* Required, read-write, boolean property */

	*data = data_new_boolean(TESTBOOL1);

	return (ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_write_boolPropTest(rad_instance_t *inst, adr_attribute_t *attr,

    data_t *data, data_t **error)

{

	/* Required, read-write, boolean property */

	return ((data_to_boolean(data) != TESTBOOL1) ? ce_object : ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_read_intPropTest(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	/* Required, read-write, int property */

	*data = data_new_integer(TESTINT1);

	return (ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_write_intPropTest(rad_instance_t *inst, adr_attribute_t *attr,

    data_t *data, data_t **error)

{

	/* Required, read-write, int property */

	return ((data_to_integer(data) != TESTINT1) ? ce_object : ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_read_strPropTest1(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	/* Required, read-only, string property */

	*data = data_new_string(TESTSTR1, lt_const);

	return (*data == NULL ? ce_object : ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_write_strPropTest2(rad_instance_t *inst, adr_attribute_t *attr,

    data_t *data, data_t **error)

{

	/* Nullable, write-only, string property */

	return ((data != NULL && strcmp(data_to_string(data), TESTSTR2) != 0) ?

	    ce_object : ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_read_uniArmTest1(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	static int toggle = 0;

	*data = NULL;

	data_t *u;

	if (toggle % 4 == 0) {

		u = data_new_union(&t__EnumUnionA, &e__EnumDisc_eval1,

		    data_new_integer(TESTINT1));

	} else if (toggle % 4 == 1) {

		u = data_new_union(&t__EnumUnionA, &e__EnumDisc_eval2,

		    data_new_boolean(TESTBOOL1));

	} else if (toggle % 4 == 2) {

		u = data_new_union(&t__EnumUnionA, &e__EnumDisc_eval3, NULL);

	} else { /* default arm */

		u = data_new_union(&t__EnumUnionA, &e__EnumDisc_eval4,

		    data_new_opaque(TESTSTR1, strlen(TESTSTR1), lt_const));

	}

	toggle++;

	if (data_purify_deep(u) == NULL)

		return (ce_object);

	*data = u;

	return (ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_write_uniArmTest1(rad_instance_t *inst, adr_attribute_t *attr,

    data_t *data, data_t **error)

{

	if (data == NULL)

		return (ce_object);

	data_t *disc = union_get_arm(data);

	data_t *value = union_get(data);

	conerr_t err = ce_object;

	if (disc != NULL) {

		if (disc == &e__EnumDisc_eval1) {

			if (data_to_integer(value) == TESTINT2)

				err = ce_ok;

		} else if (disc == &e__EnumDisc_eval2) {

			if (data_to_boolean(value) == TESTBOOL2)

				err = ce_ok;

		} else if (disc == &e__EnumDisc_eval3) {

			if (value == NULL)

				err = ce_ok;

		} else {

			char *buf = data_to_opaque(value);

			int len = opaque_size(value);

			if (len == strlen(TESTSTR2) &&

			    memcmp(buf, TESTSTR2, len) == 0)

				err = ce_ok;

		}

	}

	return (err);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_read_uniArmTest2(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	static int toggle = 0;

	*data = NULL;

	data_t *u;

	if (toggle % 3 == 0) {

		u = data_new_union(&t__EnumUnionB, &e__EnumDisc_eval1,

		    data_new_integer(TESTINT1));

		toggle++;

	} else if (toggle % 3 == 1) {

		u = data_new_union(&t__EnumUnionB, &e__EnumDisc_eval2,

		    data_new_boolean(TESTBOOL1));

		toggle++;

	} else {

		u = data_new_union(&t__EnumUnionB, &e__EnumDisc_eval3,

		    data_new_string(TESTSTR1, lt_const));

		toggle++;

	}

	if (data_purify_deep(u) == NULL)

		return (ce_object);

	*data = u;

	return (ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_write_uniArmTest2(rad_instance_t *inst, adr_attribute_t *attr,

    data_t *data, data_t **error)

{

	if (data == NULL)

		return (ce_object);

	data_t *disc = union_get_arm(data);

	data_t *value = union_get(data);

	conerr_t err = ce_object;

	if (disc != NULL && value != NULL) {

		if (disc == &e__EnumDisc_eval1) {

			if (data_to_integer(value) == TESTINT2)

				err = ce_ok;

		} else if (disc == &e__EnumDisc_eval2) {

			if (data_to_boolean(value) == TESTBOOL2)

				err = ce_ok;

		} else {

			if (strcmp(data_to_string(value), TESTSTR2) == 0)

				err = ce_ok;

		}

	}

	return (err);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_invoke_retvalTest(rad_instance_t *inst, adr_method_t *meth,

    data_t **ret, data_t **args, int count, data_t **error)

{

	 */

	const char *s = data_to_string(args[0]);

	*ret = data_new_string(s, lt_copy);

	return (*ret == NULL ? ce_object : ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_invoke_argvalTest(rad_instance_t *inst, adr_method_t *meth,

    data_t **ret, data_t **args, int count, data_t **error)

{

	 */

	if (args[0] != NULL) {

		const char *s = data_to_string(args[0]);

		*ret = data_new_string(s, lt_copy);

	} else {

		*ret = data_new_string(TESTSTR2, lt_const);

	}

	return (*ret == NULL ? ce_object : ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_invoke_readAcct(rad_instance_t *inst, adr_method_t *meth,

    data_t **ret, data_t **args, int count, data_t **error)

{

	*ret = NULL;

	/* Account id is non-nullable */

	data_t *datap = struct_get(args[0], "acctName");

	const char *aname = data_to_string(datap);

	if (strcmp(ACCTNAME1, aname) != 0 &&

	    strcmp(ACCTNAME2, aname) != 0)

		return (make_error(&e__AcctErrorCode_invalidName, error));

	datap = struct_get(args[0], "acctNumber");

	const char *anum = data_to_string(datap);

	if (strcmp(ACCTNUM1, anum) != 0 &&

	    strcmp(ACCTNUM2, anum) != 0)

		return (make_error(&e__AcctErrorCode_invalidNumber, error));

	data_t *acct = make_acct(aname, anum);

	if (acct == NULL)

		return (ce_nomem);

	*ret = acct;

	return (ce_ok);

}

/*ARGSUSED*/

conerr_t

api_CompatTest_invoke_writeAcct(rad_instance_t *inst, adr_method_t *meth,

    data_t **ret, data_t **args, int count, data_t **error)

{

	*ret = NULL;

	/* All fields are non-nullable */

	data_t *datap = struct_get(args[0], "acctId");

	const char *aname = data_to_string(struct_get(datap, "acctName"));

	if (strcmp(ACCTNAME1, aname) != 0 &&

	    strcmp(ACCTNAME2, aname) != 0)

		return (make_error(&e__AcctErrorCode_invalidName, error));

	const char *anum = data_to_string(struct_get(datap, "acctNumber"));

	if (strcmp(ACCTNUM1, anum) != 0 &&

	    strcmp(ACCTNUM2, anum) != 0)

		return (make_error(&e__AcctErrorCode_invalidNumber, error));

	datap = struct_get(args[0], "acctPassword");

	if (datap != NULL) {

		const char *apass = data_to_secret(datap);

		if (strcmp(ACCTPASS, apass) != 0)

			return (make_error(&e__AcctErrorCode_invalidPassword,

			    error));

	}

	datap = struct_get(args[0], "acctLocation");

	if (datap != NULL) {

		const char *aloc = data_to_string(datap);

		if (strcmp(ACCTLOCN, aloc) != 0)

			return (make_error(&e__AcctErrorCode_invalidLocation,

			    error));

	}

	data_t *acct = make_acct(aname, anum);

	if (acct == NULL)

		return (ce_nomem);

	*ret = acct;

	return (ce_ok);

}

static conerr_t

make_error(data_t *code, data_t **error)

{

	data_t *e = data_new_struct(&t__AcctError);

	struct_set(e, "acctErrorCode", code);

	if (data_purify(e) == NULL)

		return (ce_nomem);

	*error = e;

	return (ce_object);

}

static data_t *

make_acct(const char *aname, const char *anum)

{

	data_t *aid = data_new_struct(&t__AcctId);

	struct_set(aid, "acctName", data_new_string(aname, lt_const));

	struct_set(aid, "acctNumber", data_new_string(anum, lt_const));

	data_t *atype = data_new_struct(&t__AcctType);

	struct_set(atype, "acctType", ACCTCHECK);

	data_t *acct = data_new_struct(&t__AcctDetails);

	struct_set(acct, "acctId", aid);

	/* Account location, type are non-nullable */

	struct_set(acct, "acctLocation", data_new_string(ACCTLOCN, lt_const));

	struct_set(acct, "acctType", atype);

	struct_set(acct, "acctBalance", data_new_uinteger(ACCTBAL));

	if (!data_verify(acct, NULL, B_TRUE)) {

		data_free(acct);

		return (NULL);

	}

	return (acct);

}

static rad_modinfo_t modinfo = {

	"test-compat-cnew", "compatibility (cnew) test module"

};

int

_rad_init(void *handle)

{

	if (rad_module_register(handle, RAD_MODVERSION, &modinfo) == -1)

		return (-1);

	if (rad_isproxy)

		return (0);

	(void) cont_insert_singleton(rad_container,

	    adr_name_vcreate("com.oracle.solaris.rad.test.compat", 1,

	    "type", "cnew"), &api_CompatTest_svr);

	return (0);

}