package remotesoft.cormd;

import remotesoft.cormd.MemberRef;
import remotesoft.javac.v8.util.*;
import remotesoft.msil.*;

import remotesoft.salamander.CSharpKeywords;
import remotesoft.salamander.CSharpWriter;
import remotesoft.salamander.ClassWriter;
import remotesoft.salamander.ILAsmWriter;

/**
    Decompile a custom attribute
*/
public class CustomAttribute
{
    /** The raw methodref token */
    protected int methodRefToken;

    /** The constructor to form this attribute */
	protected MemberRef constructor;

    /* constant values for constructor args */
	protected Object[] args;

    protected NamedArg[] namedArgs;

    /** Attribute could attach to type, method, field, property, event,
        delegate, method parameter, etc., target specifies to which
        object it attaches.
    */         
    protected Object target;

    /** in which type this attribute's target is defined */
    TypeInfo classfile = null;

    public CustomAttribute(int mdMethodRef, Object[] args, NamedArg[] namedArgs, Object target)
    {
        methodRefToken = mdMethodRef;
        this.args = args;
        this.namedArgs = namedArgs;
        this.target = target;

        classfile = getTypeInfo(target);

        constructor = classfile.getMethodRef(methodRefToken);
    }

    // also called from C++
    private static TypeInfo getTypeInfo(Object target)
    {
        TypeInfo typedef = null;
        if (target instanceof TypeInfo) {
            typedef = (TypeInfo)target;
        } else if (target instanceof MemberInfo) {
            typedef = ((MemberInfo)target).getDeclaringType();
        } else if (target instanceof ParameterInfo) {
            typedef = ((ParameterInfo)target).parent.getDeclaringType();
        } else if (target instanceof ModuleInfo) {
            typedef = ((ModuleInfo)target).getGlobalType();
        } else {
            System.err.println("CustomAttribute target yet to handle: " + target.getClass().getName());
        }

        return typedef;
    }

    public Object[] getArgs()
    {
        return args;
    }

    public NamedArg[] getNamedArgs()
    {
        return namedArgs;
    }

    private static void emitStringAsILAsm(ByteBuffer buf, String str)
    {
        if (str == null) {
            buf.appendByte(-1);
            return;
        }

        int len = str.length();
        if (len <= 127)
        {
            buf.appendByte((byte)len);
        }
        else if (len <= 16383)
        {
            buf.appendByte((byte)(len >> 8 | 128));
            buf.appendByte((byte)(len & 255));
        }
        else
        {
            buf.appendByte((byte)(len >> 24 | 192));
            buf.appendByte((byte)(len >> 16 & 255));
            buf.appendByte((byte)(len >> 8 & 255));
            buf.appendByte((byte)(len & 255));
        }

        Name nm = Name.fromString(str);
        byte[] utfs = nm.toUtf();
        buf.appendBytes(utfs);
    }

    /** write a constant value according to ILAsm custom attribute blob format */
    private void writeValueAsILAsm(ByteBuffer tmp, Type t, Object val)
    {
        if (t.isBoolean()) {
			boolean z = ((Boolean)val).booleanValue();
			tmp.appendByte(z?1:0);
		} else if (t.isI1()) {
			byte b = ((Byte)val).byteValue();
			tmp.appendByte(b);
		} else if (t.isU1()) {
			short s = ((Short)val).shortValue();
			tmp.appendByte((byte)s);
		} else if (t.isChar()) {
			char c = ((Character)val).charValue();
			tmp.appendCharWithLittleEndian(c);
		} else if (t.isU2()) {
			int n = ((Integer)val).intValue();
			tmp.appendShortWithLittleEndian((short)n);
		} else if (t.isI2()) {
			short s = ((Short)val).shortValue();
			tmp.appendShortWithLittleEndian(s);
		} else if (t.isI4()) {
			int n = ((Integer)val).intValue();
			tmp.appendIntWithLittleEndian(n);
		} else if (t.isU4()) {
			long l = ((Long)val).longValue();
			tmp.appendIntWithLittleEndian((int)l);
		} else if (t.isI8() || t.isU8()) {
			long l = ((Long)val).longValue();
			tmp.appendLongWithLittleEndian(l);
		} else if (t.isR4()) {
			float f = ((Float)val).floatValue();
			tmp.appendFloatWithLittleEndian(f);
		} else if (t.isR8()) {
			double d = ((Double)val).doubleValue();
			tmp.appendDoubleWithLittleEndian(d);
		} else if (t.isString() || t.equals(Type.System_Type)) {
			emitStringAsILAsm(tmp, (String)val);
		} else if (t.isSZArray()) {
            Object[] values = (Object[])val;
            if (values == null) {
                tmp.appendByte(-1);
            } else {// a int32 length followed by that number of elem values
                tmp.appendIntWithLittleEndian(values.length);
                for (int i=0; i<values.length; i++)
                    writeValueAsILAsm(tmp, t.getElementType(), values[i]);
            }
		} else if (t.isValueType()) {
            // see native code GetCustomAttribute() function for the confusion, might be a .NET bug
            // enum base type suppose to be encoded in the CustomAttribute blob, but csc
            // and ilasm do not encode that info, so we use int32 type here, it seems working
            TypeInfo enumtype = t.loadDefinition();
            Type underlyingType = enumtype.getEnumUnderlyingType();
    		if (underlyingType == null) // use hard coded type, may cause crash
	    		underlyingType = Type.I4;
            writeValueAsILAsm(tmp, underlyingType, val);
		} else if (t.isObject()) {
            TypeValue tv = (TypeValue)val;
            byte tc = tv.typecode;
            Object value = tv.value;
            tmp.appendByte(tc);
            Type serializedType = null;
            if (tc == TypeValue.SERIALIZATION_TYPE_TAGGED_OBJECT) {
                System.err.println("yet to handle: SERIALIZATION_TYPE_TAGGED_OBJECT.");
            } else if (tc == TypeValue.SERIALIZATION_TYPE_TYPE) {
                serializedType = Type.STRING;
            } else if (tc == TypeValue.SERIALIZATION_TYPE_ENUM) {
                String s = tv.enumTypename;
			    emitStringAsILAsm(tmp, s);

                TypeInfo enumtype = ModuleInfo.currentAssembly.loadType(s);
                Type underlyingType = enumtype != null ? enumtype.getEnumUnderlyingType() : null;
    		    if (underlyingType == null) // use hard coded type, may cause crash
	    		    underlyingType = Type.I4;

                serializedType = underlyingType;
                value = tv.value;
            } else if (tc == Type.ELEMENT_TYPE_SZARRAY) {
                serializedType = new ArrayType(tc, Type.createSimpleType(tv.elemtypecode));
                tmp.appendByte(tv.elemtypecode);
            } else {
                serializedType = Type.createSimpleType(tc);
            }

            writeValueAsILAsm(tmp, serializedType, value);
        }

    }

    /** Emit type for named arg */
    private static void emitType(ByteBuffer buf, Type t)
    {
        byte typecode = t.typecode;
        buf.appendByte(typecode);
        if (typecode == TypeValue.SERIALIZATION_TYPE_ENUM)
            emitStringAsILAsm(buf, t.getAssemblyQualifiedName());
        else if (typecode == Type.ELEMENT_TYPE_SZARRAY)
            emitType(buf, t.getElementType());
    }

    /*
    customAttrDecl      : '.custom' customType
                        | '.custom' customType '=' compQstring
                        | customHead bytes ')'
                        | '.custom' '(' customType ')' customType

                        | '.custom' '(' customType ')' customType '=' compQstring
                        | customHeadWithOwner bytes ')'
                        ;
    */
    public void outputAsILAsm(ByteBuffer buf)
    {
        buf.appendName(ILAsmKeywords._custom);
        buf.appendByte(' ');
        constructor.outputAsILAsm(buf);
        buf.appendByte(' ');
        buf.appendByte('=');
        buf.appendByte(' ');
        buf.appendByte('(');

        ByteBuffer tmp = new ByteBuffer();

        // CustomAttrib starts with a Prolog - an unsigned int16, with value 0x0001
        tmp.appendShortWithLittleEndian((short)0x0001);

        // here comes the argument
        Type[] argTypes =  constructor.getSignature().getArgTypes();
        for (int i=0; i<argTypes.length; i++) {
            Type t = argTypes[i];
            writeValueAsILAsm(tmp, t, args[i]);
        }

        // NumNamed is 0, int16
        tmp.appendShortWithLittleEndian((short)namedArgs.length);
        for (int i=0; i<namedArgs.length; i++) {
            NamedArg narg = namedArgs[i];
            tmp.appendByte(narg.kind);
            emitType(tmp, narg.type);
            writeValueAsILAsm(tmp, Type.STRING, narg.name);
            writeValueAsILAsm(tmp, new Type(narg.typecode), narg.value);
        }

        ILAsmWriter.writeHexBytes(buf, tmp.elems, tmp.length);

        buf.appendByte(' ');
        buf.appendByte(')');
    }

    private void writeValue(ByteBuffer buf, Type t, Object val)
    {
        if (t.equals(Type.System_Type)) {
            buf.appendName(ClassWriter.currentWriter.mapKeyword(CSharpKeywords._typeof));
            buf.appendByte('(');
			// Nov-06-02, fully qualified type name may come here, e.g., System.Drawing.Design.UITypeEditor,System.Drawing, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
			// typeof (C#), GetType (VB) only works on the type name, not the assembly,
			String fullyQualifiedName = (String)val;
			int comma = fullyQualifiedName.indexOf(',');
			if (comma > 0) {
				fullyQualifiedName = fullyQualifiedName.substring(0, comma);
			}
            buf.appendString(classfile.toSimpleName(fullyQualifiedName));
            buf.appendByte(')');
        } else if (t.isSZArray()) {
            if (!remotesoft.salamander.Main.writer.isCPP()) {            
                buf.appendName(CSharpKeywords._new);
                buf.appendByte(' ');
                buf.appendString(t.toString());
            }
            buf.appendByte('{');
            Object[] values = (Object[])val;
            for (int j=0; j<values.length; j++) {
                if (j != 0) {
                    buf.appendByte(',');
                    buf.appendByte(' ');
                }
                writeValue(buf, t.getElementType(), values[j]);
            }
            buf.appendByte('}');
        } else if (!t.isPrimitive() && t.isValueType() || t.typecode == TypeValue.SERIALIZATION_TYPE_ENUM) {
            // register enum type as an include in .h file
            if (t instanceof TypeInfo && remotesoft.salamander.Main.writer.isCPP()) {
                remotesoft.salamander.ManagedCppWriter writer = (remotesoft.salamander.ManagedCppWriter)remotesoft.salamander.Main.writer;
                if (writer.hfile) {
                    writer.insertHFileInclude((TypeInfo)t);
                }
            }
            TypeInfo enumtype = t.loadDefinition();
            Type underlyingType = enumtype != null ? enumtype.getEnumUnderlyingType() : null;
    		if (underlyingType == null) // use hard coded type, may cause crash
	    		underlyingType = Type.I4;

            if (enumtype != null) {
                buf.appendString(classfile.toSimpleName(enumtype));
                if (remotesoft.salamander.Main.writer.isCPP())
                    buf.appendAsciiString("::");
                else
                    buf.appendByte('.');
                buf.appendAsciiString(ClassWriter.currentWriter.toLiteral(enumtype, val));
            } else {
                writeValue(buf, underlyingType, val);
            }
		} else if (t.isObject()) {
            TypeValue tv = (TypeValue)val;
            byte tc = tv.typecode;
            Object value = tv.value;
            Type serializedType = null;
            if (tc == TypeValue.SERIALIZATION_TYPE_TAGGED_OBJECT) {
                System.err.println("yet to handle: SERIALIZATION_TYPE_TAGGED_OBJECT.");
            } else if (tc == TypeValue.SERIALIZATION_TYPE_TYPE) {
                serializedType = Type.System_Type;
            } else if (tc == TypeValue.SERIALIZATION_TYPE_ENUM) {
                String s = tv.enumTypename;

                TypeInfo enumtype = ModuleInfo.currentAssembly.loadType(s);
                Type underlyingType = enumtype != null ? enumtype.getEnumUnderlyingType() : null;
    		    if (underlyingType == null) // use hard coded type, may cause crash
	    		    underlyingType = Type.I4;

                if (enumtype != null) {
                    classfile.registerType(enumtype);
                    buf.appendString(classfile.toSimpleName(enumtype));
                    if (remotesoft.salamander.Main.writer.isCPP())
                        buf.appendAsciiString("::");
                    else    
                        buf.appendByte('.');
                    buf.appendAsciiString(ClassWriter.currentWriter.toLiteral(enumtype, tv.value));
                    return;
                }
                serializedType = underlyingType;
                value = tv.value;
            } else if (tc == Type.ELEMENT_TYPE_SZARRAY) {
                serializedType = new ArrayType(tc, Type.createSimpleType(tv.elemtypecode));
            } else {
                serializedType = Type.createSimpleType(tc);
            }

            writeValue(buf, serializedType, value);

            /*
            TypeValue tv = (TypeValue)val;
            String typename = ev.typename;
            int enumVal = ev.value;
            buf.appendAsciiString(String.valueOf(enumVal));
            */
            // put a comment here to remind that it should really a Enum here
            //buf.appendAsciiString(" /* should replace with a field of enum ");
            //buf.appendAsciiString(typename);
            //buf.appendAsciiString(" */");
        } else {
            if (t.isString() && val == null)                 
                buf.appendAsciiString(ClassWriter.currentWriter.nullLiteral());
            else
                buf.appendAsciiString(ClassWriter.currentWriter.toLiteral(t, val));
        }
    }

    /** Generate a C# rep, e.g., [MyAttribute("Christina", "Zhang")] */
    public void output(ByteBuffer buf, boolean isReturnTarget)
    {
        if (ClassWriter.targetLanguage != ClassWriter.VB)
            buf.appendByte('[');
            
        if (isReturnTarget) {
            if (remotesoft.salamander.Main.writer.isCPP())
                buf.appendAsciiString("returnvalue: ");
            else
                buf.appendAsciiString("return: ");
        } else if (classfile.isFakedGlobalType()) {
            // attributes for an assembly
            buf.appendAsciiString("assembly: ");
        }

        output(buf);
    }

    /** Generate a C# rep, e.g., [MyAttribute("Christina", "Zhang")] */
    public void output(ByteBuffer buf, String target)
    {
        if (ClassWriter.targetLanguage != ClassWriter.VB)
            buf.appendByte('[');
                              
        buf.appendAsciiString(target);
        buf.appendByte(':');
        buf.appendByte(' ');
        output(buf);
    }
    
    private void output(ByteBuffer buf)
    {
        buf.appendString(classfile.getFlatName(constructor.owner));

        // MC++ does not like empty constructor
        // e.g., [SerializableAttribute()] compiling error
        //    ==> [SerializableAttribute], OK
        if (remotesoft.salamander.Main.writer.isCPP() &&
           constructor.getSignature().getArgTypes().length ==0 && 
           namedArgs.length == 0) {
           buf.appendByte(']');
           return;
        }
        
        buf.appendByte('(');
        // here comes the arguments
        Type[] argTypes =  constructor.getSignature().getArgTypes();
        for (int i=0; i<argTypes.length; i++) {
            if (i != 0) {
                buf.appendByte(',');
                buf.appendByte(' ');
            }
            Type t = argTypes[i];
            writeValue(buf, t, args[i]);
        }
        boolean first = true;
        // named arguments
        for (int i=0; i<namedArgs.length; i++) {
            if (argTypes.length != 0 || !first) {
                buf.appendByte(',');
                buf.appendByte(' ');
            }
            first = false; 
            NamedArg narg = namedArgs[i];
            buf.appendString(narg.name);
            if (ClassWriter.targetLanguage == ClassWriter.VB)
                buf.appendByte(':');
            buf.appendByte('=');
            //classfile.registerType(narg.type);
            // at this point namespace already outputed, should do this before
            //  emitting "using" statement, use full name here 
            writeValue(buf, narg.type, narg.value);
        }

        buf.appendByte(')');

        if (ClassWriter.targetLanguage != ClassWriter.VB)
            buf.appendByte(']');
    }

    /** Check if this is a System.ParamArrayAttribute */
    public boolean isParamArrayAttribute()
    {
        if (constructor.owner.equals(Type.ParamArrayAttribute)) {
            return constructor.signature.getArgTypes().length == 0;
        } else
            return false;
    }

    /** Check if this is a System.ParamArrayAttribute */
    public boolean isDefaultMemberAttribute()
    {
        return constructor.owner.equals(Type.DefaultMemberAttribute);
    }

	/** Check if this is a System.Diagnostics.DebuggableAttribute */
    public boolean isDebuggableAttribute()
    {
        return constructor.owner.equals(Type.DebuggableAttribute);
    }

    /** Get the type that defines this attribute */
    public Type getDeclaringType()
    {
        return constructor.owner;
    }
}

/** When an attribute takes System.Object type as an argument, the blob keeps
    a type code and a value
*/
final class TypeValue
{
    // taken from CorHdr.h
    final static byte SERIALIZATION_TYPE_TYPE         = 0x50;
    final static byte SERIALIZATION_TYPE_TAGGED_OBJECT= 0x51;

    final static byte SERIALIZATION_TYPE_ENUM         = 0x55;
/** Enum value. A type name and an integer value is kept in the metadata.
e.g.,
.custom instance void MyAttribute::.ctor(object) = ( 01 00 55 20 53 79 73 74 65 6D 2E 52 65 66 6C 65   // ..U System.Refle
                                                       63 74 69 6F 6E 2E 54 79 70 65 41 74 74 72 69 62   // ction.TypeAttrib
                                                       75 74 65 73 01 00 00 00 00 00 )                   // utes......
*/
    byte typecode;
    byte elemtypecode; // array element type code

    String enumTypename; // type name when typecode == SERIALIZATION_TYPE_ENUM

    Object value;

    TypeValue(byte typecode, Object value)
    {
        this.typecode = typecode;
        this.value = value;
    }

    TypeValue(byte typecode, byte elemtypecode, Object value)
    {
        this(typecode, value);
        this.elemtypecode = elemtypecode;
    }

    TypeValue(byte typecode, String enumTypename, Object value)
    {
        this(typecode, value);
        this.enumTypename = enumTypename;
    }
}