/*

 * 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) 2010, Oracle and/or its affiliates. All rights reserved.

 */

package org.opensolaris.os.rad;

import java.text.ParseException;

import java.io.IOException;

import java.lang.reflect.Array;

import java.math.BigInteger;

import java.text.SimpleDateFormat;

import java.util.*;

import javax.management.ObjectName;

import javax.management.MalformedObjectNameException;

import javax.management.openmbean.*;

import org.opensolaris.os.xdr.*;

import org.opensolaris.os.adr.*;

public class ADRXDR {

    private static void setOpenType(Type t, OpenType<?> ot) {

	t.setAuxData(null, ot);

    }

    public static OpenType<?> getOpenType(Type t) {

	OpenType<?> type = (OpenType<?>)t.getAuxData(null);

	if (type == null) {

	    type = toOpenType(t);

	    setOpenType(t, type);

	}

	return type;

    }

    static Type readType(XDRInputStream typestr) throws IOException {

	return readType(typestr, false);

    }

    static Type readType(XDRInputStream typestr, boolean opt)

	throws IOException {

	/* Special case for error types */

	if (opt && !typestr.getBoolean())

	    return null;

	int type = typestr.getInteger();

	switch (type) {

	case 0:

	    return Type.getType(StdType.VOID);

	case 1:

	    return Type.getType(StdType.BOOLEAN);

	case 2:

	    return Type.getType(StdType.INTEGER);

	case 3:

	    return Type.getType(StdType.STRING);

	case 4:

	    return Type.getArrayType(readType(typestr));

	case 5:

	    String sname = typestr.getString();

	    int nfields = typestr.getInteger();

	    List<Field> fields = new ArrayList<Field>(nfields);

	    for (int i = 0; i < nfields; i++) {

		String name = typestr.getString();

		boolean optional = typestr.getBoolean();

		Type ftype = readType(typestr);

		fields.add(new Field(name, ftype, optional));

	    }

	    return new Type.ComplexType(sname, fields, null);

	case 6:

	    String ename = typestr.getString();

	    int nvalues = typestr.getInteger();

	    List<Type.EnumValue> values =

		new ArrayList<Type.EnumValue>(nvalues);

	    for (int i = 0; i < nvalues; i++)  {

		values.add(new Type.EnumValue(typestr.getString(),

		    typestr.getInteger()));

	    }

	    return new Type.EnumType(ename, values);

	case 7:

	    return Type.getType(StdType.OPAQUE);

	case 8:

	    return Type.getType(StdType.LONG);

	case 9:

	    return Type.getType(StdType.TIME);

	case 10:

	    return Type.getType(StdType.ULONG);

	case 11:

	    return Type.getType(StdType.UINTEGER);

	case 12:

	    return Type.getType(StdType.OBJECT);

	default:

	    throw new IOException("Bad type id: " + type);

	}

    }

    static OpenType<?> toOpenType(Type type) {

	if (type instanceof Type.BuiltinType) {

	    Type.BuiltinType bt = (Type.BuiltinType)type;

	    switch (bt.getType()) {

	    case VOID:

		return SimpleType.VOID;

	    case BOOLEAN:

		return SimpleType.BOOLEAN;

	    case INTEGER:

		return SimpleType.INTEGER;

	    case STRING:

		return SimpleType.STRING;

	    case OPAQUE:

		return ArrayType.getPrimitiveArrayType(byte[].class);

	    case LONG:

		return SimpleType.LONG;

	    case TIME:

		return SimpleType.DATE;

	    case OBJECT:

		return SimpleType.OBJECTNAME;

	    case UINTEGER:

		return SimpleType.LONG;

	    case ULONG:

		return SimpleType.BIGINTEGER;

	    }

	} else if (type instanceof Type.ArrayType) {

	    Type atype = ((Type.ArrayType)type).getType();

	    if (atype instanceof Type.BuiltinType) {

		Type.BuiltinType bt = (Type.BuiltinType)atype;

		if (bt.getType() == StdType.BOOLEAN)

			return ArrayType.getPrimitiveArrayType(boolean[].class);

		if (bt.getType() == StdType.INTEGER)

			return ArrayType.getPrimitiveArrayType(int[].class);

		if (bt.getType() == StdType.LONG ||

		    bt.getType() == StdType.UINTEGER)

			return ArrayType.getPrimitiveArrayType(long[].class);

	    }

	    try {

		return ArrayType.getArrayType(getOpenType(atype));

	    } catch (OpenDataException ex) {

		/* If readType returns an OpenType of an invalid class */

		/* Shouldn't happen? */

		return null;

	    }

	} else if (type instanceof Type.ComplexType) {

	    Type.ComplexType ct = (Type.ComplexType)type;

	    List<Field> fields = ct.getFields();

	    String fnames[] = new String[fields.size()];

	    OpenType<?> ftypes[] = new OpenType<?>[fields.size()];

	    int i = 0;

	    for (Field field : fields) {

		fnames[i] = field.getName();

		ftypes[i] = getOpenType(field.getType());

		i++;

	    }

	    try {

		String name = ct.getName();

		return new CompositeType(name, name, fnames, fnames, ftypes);

	    } catch (OpenDataException ex) {

		System.out.println("ODE caught: " + ex);

		ex.printStackTrace();

		return null;

	    }

	} else if (type instanceof Type.EnumType) {

	    return SimpleType.STRING;

	}

	throw new IllegalArgumentException();

    }

    /*

     * OpenType doesn't have direct analogues for all ADR types.  To correctly

     * decode what comes off the wire, we need to traverse the OpenType and

     * ADR types side-by-side.

     */

    static Object readData(Type realtype, XDRInputStream datastr)

	throws IOException, OpenDataException {

	if (realtype instanceof Type.BuiltinType) {

	    switch (((Type.BuiltinType)realtype).getType()) {

	    case STRING:

		return datastr.getString();

	    case OBJECT: {

		String s = datastr.getString();

		try {

		    return (new ADRName(s)).toObjectName();

		} catch (MalformedObjectNameException ex) {

		    throw new IOException("Error parsing object name: " + s,

			ex);

		} catch (NullPointerException ex) {

		    /* Can't happen */

		    throw new IOException("Error parsing object name", ex);

		}

	    }

	    case TIME: {

		String s = datastr.getString();

		SimpleDateFormat f =

		    new SimpleDateFormat("yyyy-MM-dd HH:mm:ss'Z'");

		f.setCalendar(Calendar.getInstance(

		    TimeZone.getTimeZone("UTC")));

		try {

		    return f.parse(s);

		} catch (ParseException ex) {

		    throw new IOException("Error parsing date: " + s, ex);

		}

	    }

	    case BOOLEAN:

		return datastr.getBoolean();

	    case INTEGER:

		return datastr.getInteger();

	    case LONG:

		return datastr.getHyper();

	    case OPAQUE:

		return datastr.getOpaque();

	    case UINTEGER:

		return datastr.getUInteger();

	    case ULONG:

		return datastr.getUHyper();

	    }

	} else if (realtype instanceof Type.EnumType) {

	    return datastr.getString();

	} else if (realtype instanceof Type.ArrayType) {

	    Type atype = ((Type.ArrayType)realtype).getType();

	    int count = datastr.getInteger();

	    if (atype instanceof Type.BuiltinType) {

		switch (((Type.BuiltinType)atype).getType()) {

		case STRING: {

		    String result[] = new String[count];

		    for (int i = 0; i < count; i++)

			result[i] = datastr.getString();

		    return result;

		}

		case OBJECT: {

		    ObjectName result[] = new ObjectName[count];

		    for (int i = 0; i < count; i++)

			result[i] = (ObjectName)readData(atype, datastr);

		    return result;

		}

		case TIME: {

		    Date result[] = new Date[count];

		    for (int i = 0; i < count; i++)

			result[i] = (Date)readData(atype, datastr);

		    return result;

		}

		case BOOLEAN: {

		    boolean result[] = new boolean[count];

		    for (int i = 0; i < count; i++)

			result[i] = datastr.getBoolean();

		    return result;

		}

		case INTEGER: {

		    int result[] = new int[count];

		    for (int i = 0; i < count; i++)

			result[i] = datastr.getInteger();

		    return result;

		}

		case LONG: {

		    long result[] = new long[count];

		    for (int i = 0; i < count; i++)

			result[i] = datastr.getHyper();

		    return result;

		}

		case OPAQUE:

		    throw new IOException("Opaque arrays not supported yet.");

		case UINTEGER: {

		    long result[] = new long[count];

		    for (int i = 0; i < count; i++)

			result[i] = datastr.getUInteger();

		    return result;

		}

		case ULONG: {

		    BigInteger result[] = new BigInteger[count];

		    for (int i = 0; i < count; i++)

			result[i] = datastr.getUHyper();

		    return result;

		}

		}

	    } else if (atype instanceof Type.EnumType) {

		String result[] = new String[count];

		for (int i = 0; i < count; i++)

		    result[i] = datastr.getString();

		return result;

	    } else if (atype instanceof Type.ComplexType) {

		CompositeData result[] = new CompositeData[count];

		for (int i = 0; i < count; i++)

		    result[i] = (CompositeData)readData(atype, datastr);

		return result;

	    }

	} else if (realtype instanceof Type.ComplexType) {

	    CompositeType ct = (CompositeType)getOpenType(realtype);

	    Type.ComplexType rct = (Type.ComplexType)realtype;

	    Map<String, Object> fields = new HashMap<String, Object>();

	    int count = ct.keySet().size();

	    for (int i = 0; i < count; i++) {

		String field = datastr.getString();

		Field rt = rct.getField(field);

		if (rt == null)

		    throw new IOException(String.format(

			"unknown field \"%s\" found in datastream for \"%s\".",

			field, ct.getTypeName()));

		fields.put(field, readOptional(rt.getType(), datastr));

	    }

	    return new CompositeDataSupport(ct, fields);

	}

	throw new IOException("Out of spec type when reading data:" + realtype);

    }

    static Object readOptional(Type realtype, XDRInputStream datastr)

	throws IOException, OpenDataException {

	if (!datastr.getBoolean())

	    return null;

	return readData(realtype, datastr);

    }

    static void writeData(XDROutputStream xdrs, Type realtype, Object d)

	throws IOException {

	if (realtype instanceof Type.BuiltinType) {

	    switch (((Type.BuiltinType)realtype).getType()) {

	    case STRING:

		xdrs.putString((String)d);

		break;

	    case OBJECT:

		xdrs.putString((new ADRName((ObjectName)d)).toString());

		break;

	    case TIME:

		SimpleDateFormat f =

		    new SimpleDateFormat("yyyy-MM-dd HH:mm:ss'Z'");

		f.setCalendar(Calendar.getInstance(

		    TimeZone.getTimeZone("UTC")));

		xdrs.putString(f.format((Date)d));

		break;

	    case BOOLEAN:

		xdrs.putBoolean((Boolean)d);

		break;

	    case INTEGER:

		xdrs.putInteger((Integer)d);

		break;

	    case LONG:

		xdrs.putHyper((Long)d);

		break;

	    case OPAQUE:

		xdrs.putOpaque((byte[])d);

		break;

	    case UINTEGER:

		xdrs.putUInteger((Long)d);

		break;

	    case ULONG:

		xdrs.putUHyper((BigInteger)d);

	    }

	} else if (realtype instanceof Type.EnumType) {

	    xdrs.putString((String)d);

	} else if (realtype instanceof Type.ArrayType) {

	    Type rat = ((Type.ArrayType)realtype).getType();

	    int len = Array.getLength(d);

	    xdrs.putInteger(len);

	    if (rat instanceof Type.BuiltinType) {

		switch (((Type.BuiltinType)rat).getType()) {

		case STRING: {

		    String result[] = (String[]) d;

		    for (int i = 0; i < len; i++)

			xdrs.putString(result[i]);

		    break;

		}

		case OBJECT: {

		    ObjectName result[] = (ObjectName[]) d;

		    for (int i = 0; i < len; i++)

			writeData(xdrs, rat, result[i]);

		    break;

		}

		case TIME: {

		    Date result[] = (Date[]) d;

		    for (int i = 0; i < len; i++)

			writeData(xdrs, rat, result[i]);

		    break;

		}

		case BOOLEAN: {

		    boolean result[] = (boolean[])d;

		    for (int i = 0; i < len; i++)

			xdrs.putBoolean(result[i]);

		    break;

		}

		case INTEGER: {

		    int result[] = (int[])d;

		    for (int i = 0; i < len; i++)

			xdrs.putInteger(result[i]);

		    break;

		}

		case LONG: {

		    long result[] = (long[])d;

		    for (int i = 0; i < len; i++)

			xdrs.putHyper(result[i]);

		    break;

		}

		case OPAQUE:

		    throw new IOException("Opaque arrays not supported yet.");

		case UINTEGER: {

		    long result[] = (long[])d;

		    for (int i = 0; i < len; i++)

			xdrs.putUInteger(result[i]);

		    break;

		}

		case ULONG: {

		    BigInteger result[] = (BigInteger[])d;

		    for (int i = 0; i < len; i++)

			xdrs.putUHyper(result[i]);

		    break;

		}

		}

	    } else if (rat instanceof Type.EnumType) {

		String result[] = (String[]) d;

		for (int i = 0; i < len; i++)

		    xdrs.putString(result[i]);

	    } else if (rat instanceof Type.ComplexType) {

		CompositeData result[] = (CompositeData[]) d;

		for (int i = 0; i < len; i++)

		    writeData(xdrs, rat, result[i]);

	    }

	} else if (realtype instanceof Type.ComplexType) {

	    CompositeData cd = (CompositeData)d;

	    for (Field f : ((Type.ComplexType)realtype).getFields()) {

		String s = f.getName();

		xdrs.putString(s);

		writeOptional(xdrs, f.getType(), cd.get(s));

	    }

	} else {

	    throw new IOException("Out of spec Type when writing data: " +

		realtype);

	}

    }

    static void writeOptional(XDROutputStream xdrs, Type realtype, Object d)

	throws IOException {

	if (d == null) {

	    xdrs.putBoolean(false);

	} else {

	    xdrs.putBoolean(true);

	    writeData(xdrs, realtype, d);

	}

    }

}