/*

 * 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, 2011, 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.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.charset.CharsetEncoder;

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.*;

class ADRXDR {

    /* Type IDs used by the wire protocol */

    private static final int DT_VOID = 0;

    private static final int DT_BOOLEAN = 1;

    private static final int DT_INT = 2;

    private static final int DT_STRING = 3;

    private static final int DT_ARRAY = 4;

    private static final int DT_STRUCT = 5;

    private static final int DT_ENUM = 6;

    private static final int DT_OPAQUE = 7;

    private static final int DT_LONG = 8;

    private static final int DT_TIME = 9;

    private static final int DT_ULONG = 10;

    private static final int DT_UINT = 11;

    private static final int DT_OBJECT = 12;

    private static final int DT_PASSWORD = 13;

    private static final int DT_FLOAT = 14;

    private static final int DT_DOUBLE = 15;

    private static final String CHARSET = "ISO-8859-1";

    private static Charset _charset = Charset.forName(CHARSET);

    private static char[] byteToChar(byte[] b) {

	ByteBuffer bb = ByteBuffer.wrap(b);

	CharBuffer cb = _charset.decode(bb);

	Arrays.fill(b, (byte)0);

	return cb.array();

    }

    private static byte[] charToByte(char[] c) throws IOException {

	CharBuffer cb = CharBuffer.wrap(c);

	CharsetEncoder encoder = _charset.newEncoder();

	if (!encoder.canEncode(cb))

	    throw new IOException("Unable to encode password");

	ByteBuffer bb = encoder.encode(cb);

	return bb.array();

    }

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

	t.setAuxData(null, ot);

    }

    public OpenType<?> getOpenType(Type t) {

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

	if (type == null) {

	    type = toOpenType(t);

	    setOpenType(t, type);

	}

	return type;

    }

    private EnumMapper enumMapper_;

    public ADRXDR(EnumMapper mapper) {

	enumMapper_ = mapper;

    }

    public ADRXDR() {

	/* PlainEnumMapper doesn't require a client */

	this(new PlainEnumMapper());

    }

    Type readRef(XDRInputStream typestr, List<Type> types, boolean opt)

	throws IOException {

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

	    return null;

	int type = typestr.getInteger();

	switch (type) {

	case DT_VOID:

	    return Type.getType(StdType.VOID);

	case DT_BOOLEAN:

	    return Type.getType(StdType.BOOLEAN);

	case DT_INT:

	    return Type.getType(StdType.INTEGER);

	case DT_STRING:

	    return Type.getType(StdType.STRING);

	case DT_ARRAY:

	case DT_STRUCT:

	case DT_ENUM:

	    return types.get(typestr.getInteger());

	case DT_OPAQUE:

	    return Type.getType(StdType.OPAQUE);

	case DT_LONG:

	    return Type.getType(StdType.LONG);

	case DT_TIME:

	    return Type.getType(StdType.TIME);

	case DT_ULONG:

	    return Type.getType(StdType.ULONG);

	case DT_UINT:

	    return Type.getType(StdType.UINTEGER);

	case DT_OBJECT:

	    return Type.getType(StdType.OBJECT);

	case DT_PASSWORD:

	    return Type.getType(StdType.PASSWORD);

	case DT_FLOAT:

	    return Type.getType(StdType.FLOAT);

	case DT_DOUBLE:

	    return Type.getType(StdType.DOUBLE);

	default:

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

	}

    }

    Type readType(XDRInputStream typestr, List<Type> types) throws IOException {

	Type result;

	int type = typestr.getInteger();

	switch (type) {

	case DT_ARRAY:

	    result = Type.getArrayType(readRef(typestr, types, false));

	    break;

	case DT_STRUCT:

	    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 = readRef(typestr, types, false);

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

	    }

	    result = new Type.ComplexType(sname, fields, null);

	    break;

	case DT_ENUM:

	    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()));

	    }

	    result = new Type.EnumType(ename, values, fallback);

	    break;

	default:

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

	}

	types.add(result);

	return result;

    }

    List<Type> readTypes(XDRInputStream typestr) throws IOException {

	int ntypes = typestr.getInteger();

	ArrayList<Type> types = new ArrayList<Type>(ntypes);

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

	    readType(typestr, types);

	return types;

    }

    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;

	    case PASSWORD:

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

	    case FLOAT:

		return SimpleType.FLOAT;

	    case DOUBLE:

		return SimpleType.DOUBLE;

	    }

	} 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);

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

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

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

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

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

		    return ArrayType.getPrimitiveArrayType(double[].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 enumMapper_.toOpenType((Type.EnumType)type);

	}

	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.

     */

    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();

	    case PASSWORD:

		return byteToChar(datastr.getOpaque());

	    case FLOAT:

		return datastr.getFloat();

	    case DOUBLE:

		return datastr.getDouble();

	    }

	} else if (realtype instanceof Type.EnumType) {

	    Type.EnumType et = (Type.EnumType)realtype;

	    int index = datastr.getInteger();

	    if (index > 0 && index <= et.getValues().size())

		return enumMapper_.fromWire(et, et.getValues().get(index - 1));

	    throw new IOException("Enumeration value out of range:");

	} 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: {

		    Integer result[] = new Integer[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;

		}

		case PASSWORD: {

		    char result[][] = new char[count][];

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

			result[i] = byteToChar(datastr.getOpaque());

		    return result;

		}

		case FLOAT: {

		    Float result[] = new Float[count];

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

			result[i] = datastr.getFloat();

		    return result;

		}

		case DOUBLE: {

		    Double result[] = new Double[count];

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

			result[i] = datastr.getDouble();

		    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>();

	    for (Field field : rct.getFields())

		fields.put(field.getName(),

		    readOptional(field.getType(), datastr));

	    return new CompositeDataSupport(ct, fields);

	}

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

    }

    Object readOptional(Type realtype, XDRInputStream datastr)

	throws IOException, OpenDataException {

	if (!datastr.getBoolean())

	    return null;

	return readData(realtype, datastr);

    }

    static Stability readStability(XDRInputStream datastr)

	throws IOException {

	int stability = datastr.getInteger();

	switch (stability) {

	case 1:

	    return Stability.PRIVATE;

	case 2:

	    return Stability.UNCOMMITTED;

	case 3:

	    return Stability.COMMITTED;

	default:

	    throw new IOException("Invalid stability value: " + stability);

	}

    }

    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);

		break;

	    case PASSWORD:

		char[] c = (char[])d;