//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------

namespace Microsoft.Build.Tasks.Xaml
{
    using System.Collections.Generic;
    using System.Xaml;
    using System.Collections.ObjectModel;
    using System.Runtime;
    using System;
    using System.ComponentModel;
    using System.Reflection;
    using System.Globalization;
    using XamlBuildTask;

    public sealed class AttributeData 
    {
        static CultureInfo invariantEnglishUS = CultureInfo.ReadOnly(new CultureInfo("en-us", false));
        List<AttributeParameterData> parameters;
        Dictionary<string, AttributeParameterData> properties;        

        public XamlType Type
        {
            get;
            set;
        }

        public IList<AttributeParameterData> Parameters
        {
            get
            {
                if (this.parameters == null)
                {
                    this.parameters = new List<AttributeParameterData>();
                }
                return parameters;
            }
        }

        public IDictionary<string, AttributeParameterData> Properties
        {
            get
            {
                if (properties == null)
                {
                    properties = new Dictionary<string, AttributeParameterData>();
                }
                return properties;
            }
        }

        // We get here when we are inside x:ClassAttributes or x:Property.Attributes. We expect the first element to be the Attribute SO.
        internal static AttributeData LoadAttributeData(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
        {
            AttributeData attributeData = null;
            reader.Read();
            if (reader.NodeType == XamlNodeType.StartObject)
            {
                attributeData = new AttributeData { Type = reader.Type };

                bool readNext = false;
                while (readNext || reader.Read())
                {
                    namespaceTable.ManageNamespace(reader);
                    readNext = false;
                    if (reader.NodeType == XamlNodeType.StartMember)
                    {
                        if (reader.Member == XamlLanguage.Arguments)
                        {
                            foreach (AttributeParameterData parameterData in ReadParameters(reader.ReadSubtree(), namespaceTable, rootNamespace))
                            {
                                attributeData.Parameters.Add(parameterData);
                            }
                            readNext = true;
                        }
                        else if (!reader.Member.IsDirective)
                        {
                            KeyValuePair<string, AttributeParameterData> propertyInfo = ReadAttributeProperty(reader.ReadSubtree(), namespaceTable, rootNamespace);
                            attributeData.Properties.Add(propertyInfo.Key, propertyInfo.Value);
                            readNext = true;
                        }
                    }
                }
            }
            return attributeData;
        }

        // Read the Property on the attribute.
        private static KeyValuePair<string, AttributeParameterData> ReadAttributeProperty(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
        {
            reader.Read();
            Fx.Assert(reader.Member != null, "Member element should not be null");
            XamlMember member = reader.Member;

            AttributeParameterData propertyInfo = new AttributeParameterData();

            if (member.Type != null && !member.Type.IsUnknown)
            {
                propertyInfo.Type = member.Type;
            } 
            
            ReadParamInfo(reader, member.Type, namespaceTable, rootNamespace, propertyInfo);
            return new KeyValuePair<string, AttributeParameterData>(member.Name, propertyInfo);
        }

        // Read the parameters on the Attribute. We expect the parameters to be in the order in which they are supposed to appear in the output code.
        // Here we are inside x:Arguments and we expect a list of parameters.
        private static IList<AttributeParameterData> ReadParameters(XamlReader reader, NamespaceTable namespaceTable, string rootNamespace)
        {
            IList<AttributeParameterData> parameters = new List<AttributeParameterData>();
            bool readNext = false;
            while (readNext || reader.Read())
            {
                readNext = false;
                if (reader.NodeType == XamlNodeType.StartObject)
                {
                    AttributeParameterData paramInfo = new AttributeParameterData();
                    ReadParamInfo(reader.ReadSubtree(), null, namespaceTable, rootNamespace, paramInfo);
                    parameters.Add(paramInfo);
                    readNext = true;
                }
            }
            return parameters;
        }

        // Read the actual parameter info, i.e. the type of the paramter and its value.
        // The first element could be a V or an SO.
        private static void ReadParamInfo(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, AttributeParameterData paramInfo)
        {
            reader.Read();
            
            bool readNext = false;
            do
            {
                readNext = false;
                if (reader.NodeType == XamlNodeType.StartObject && reader.Type == XamlLanguage.Array)
                {
                    paramInfo.IsArray = true;
                    XamlReader xamlArrayReader = reader.ReadSubtree();
                    xamlArrayReader.Read();
                    while (readNext || xamlArrayReader.Read())
                    {
                        readNext = false;
                        if (xamlArrayReader.NodeType == XamlNodeType.StartMember && xamlArrayReader.Member.Name == "Type")
                        {
                            xamlArrayReader.Read();
                            if (xamlArrayReader.NodeType == XamlNodeType.Value)
                            {
                                XamlType arrayType = XamlBuildTaskServices.GetXamlTypeFromString(xamlArrayReader.Value as string, namespaceTable, xamlArrayReader.SchemaContext);
                                if (arrayType.UnderlyingType != null)
                                {
                                    paramInfo.Type = xamlArrayReader.SchemaContext.GetXamlType(arrayType.UnderlyingType.MakeArrayType());
                                }
                                else
                                {
                                    throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(arrayType)));
                                }
                            }
                        }
                        else if (xamlArrayReader.NodeType == XamlNodeType.StartObject)
                        {
                            AttributeParameterData arrayEntry = new AttributeParameterData();
                            ReadParamInfo(xamlArrayReader.ReadSubtree(), null, namespaceTable, rootNamespace, arrayEntry);
                            paramInfo.AddArrayContentsEntry(arrayEntry);
                            readNext = true;
                        }
                    }
                }                    
                else if (reader.NodeType == XamlNodeType.StartObject || reader.NodeType == XamlNodeType.Value)
                {
                    paramInfo.IsArray = false;
                    string paramVal;
                    object paramObj = null;
                    XamlType paramType;
                    GetParamValueType(reader.ReadSubtree(), type, namespaceTable, rootNamespace, out paramVal, out paramType, out paramObj);
                    paramInfo.TextValue = paramVal;
                    paramInfo.Type = paramType;
                    paramInfo.Value = paramObj;
                }
            } while (readNext || reader.Read());
        }

        // Get the paramter value. If the value is enclosed inside nodes of the type, then get the parameter type as well. 
        // Else infer the type from the type of the property.
        private static void GetParamValueType(XamlReader reader, XamlType type, NamespaceTable namespaceTable, string rootNamespace, out string paramValue, out XamlType paramType, out Object paramObj)
        {
            paramValue = String.Empty;
            paramType = type;
            paramObj = null;
            while (reader.Read())
            {                
                if (reader.NodeType == XamlNodeType.Value)
                {
                    if (paramType != null && paramType.UnderlyingType != null)
                    {
                        if (!IsSupportedParameterType(paramType.UnderlyingType) || paramType.UnderlyingType.IsArray)
                        {
                            throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParamTypeNotSupported(paramType.UnderlyingType.FullName)));
                        }

                        paramValue = reader.Value as string;
                        if (typeof(Type).IsAssignableFrom(paramType.UnderlyingType))
                        {
                            Tuple<string, Type> result = ParseParameterValueTypeName(paramValue, rootNamespace, reader.SchemaContext, namespaceTable);
                            paramValue = result.Item1;
                            paramObj = result.Item2;
                        }
                        else
                        {
                            paramObj = ParseParameterValue(ref paramValue, paramType);
                        }
                    }                    
                    else
                    {
                        throw FxTrace.Exception.AsError(new InvalidOperationException(SR.AttributeParameterTypeUnknown(reader.Value as string)));
                    }
                }
                else if (reader.NodeType == XamlNodeType.StartObject)
                {
                    if (reader.Type == XamlLanguage.Null)
                    {
                        paramValue = null;
                        paramType = null;
                    }
                    else if (reader.Type == XamlLanguage.Type)
                    {
                        paramType = reader.SchemaContext.GetXamlType(typeof(Type));
                    }
                    else
                    {
                        paramType = reader.Type;
                    }
                }
            }
        }

        internal static bool IsSupportedParameterType(Type type)
        {
            if (type.IsArray)
            {
                return IsSupportedParameterType(type.GetElementType());
            }
            return type.IsEnum || 
                type.IsPrimitive ||
                typeof(string) == type ||
                typeof(Type).IsAssignableFrom(type);
        }

        // Given a live value for an attribute parameter, returns the text that needs to be
        // code-gened for the value.
        internal static string GetParameterText(object value, XamlType paramType)
        {
            Type type = paramType.UnderlyingType;
            if (type.IsEnum)
            {
                // Note: this doesn't support flags enums with multiple flags set, but neither
                // does the existing Dev10 code
                return type.FullName + "." + value.ToString();
            }
            else if (typeof(Type).IsAssignableFrom(type))
            {
                return ((Type)value).FullName;
            }
            else if (type == typeof(String))
            {
                return (string)value;
            }
            else if (type.IsPrimitive)
            {
                TypeConverter typeConverter = paramType.TypeConverter.ConverterInstance;
                Fx.Assert(typeConverter != null, "All primitives have TypeConverters");
                return (string)typeConverter.ConvertTo(null, invariantEnglishUS, value, typeof(string));
            }
            else
            {
                throw Fx.AssertAndThrow("Unexpected attribute parameter type");
            }
        }

        // Given the text for an attribute parameter, parses it to a live value (if possible).
        internal static object GetParameterValue(ref string paramValue, XamlType paramType)
        {
            if (typeof(Type).IsAssignableFrom(paramType.UnderlyingType))
            {
                // We can't convert a CLR type name to a Type because we don't know what assembly it's from
                return null;
            }
            return ParseParameterValue(ref paramValue, paramType);
        }

        // Parses a XAML QName to a CLR Type Name (and the corresponding ROL type, if available)
        private static Tuple<string, Type> ParseParameterValueTypeName(string paramValue, string rootNamespace, XamlSchemaContext schemaContext, NamespaceTable namespaceTable)
        {
            XamlType xamlType = XamlBuildTaskServices.GetXamlTypeFromString(paramValue, namespaceTable, schemaContext);

            string clrTypeName;
            if (!XamlBuildTaskServices.TryGetClrTypeName(xamlType, rootNamespace, out clrTypeName))
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.TypeNameUnknown(XamlBuildTaskServices.GetFullTypeName(xamlType))));
            }
            return Tuple.Create(clrTypeName, xamlType.UnderlyingType);
        }

        // Given a text value for an attribute parameter, attempts to convert it to a live value.
        // Inverse of GetParameterText.
        private static object ParseParameterValue(ref string paramValue, XamlType paramType)
        {
            object valueObj = null;
            paramValue = NormalizeParameterText(paramValue, paramType);
            if (!paramType.UnderlyingType.Assembly.ReflectionOnly)
            {
                TypeConverter typeConverter = paramType.TypeConverter.ConverterInstance;
                if (typeConverter != null && typeConverter.CanConvertFrom(paramValue.GetType()))
                {
                    try
                    {
                        valueObj = typeConverter.ConvertFrom(null, invariantEnglishUS, paramValue);
                    }
                    catch (Exception e)
                    {
                        if (Fx.IsFatal(e))
                        {
                            throw;
                        }
                        // ----ing exceptions here to avoid throwing on 
                        // a format that we don't recognize, but the compiler
                        // might be able to interpret.
                    }
                }
            }

            return valueObj;
        }

        // Get the parameter value that is to be put in the generated code as is.
        private static string NormalizeParameterText(string value, XamlType xamlType)
        {
            string paramValue;
            Type type = xamlType.UnderlyingType;
            Fx.Assert(!typeof(Type).IsAssignableFrom(type), "This method should not be called for Types");

            if (type.IsEnum)
            {
                paramValue = type.FullName + "." + value;
            }
            else if (type == typeof(String))
            {
                paramValue = value;
            }
            else if (type.IsPrimitive)
            {
                value = value.TrimStart('"');
                value = value.TrimEnd('"');

                if (type == typeof(bool))
                {
                    if (string.Compare(value, "true", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        paramValue = "true";
                    }
                    else if (string.Compare(value, "false", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        paramValue = "false";
                    }
                    else
                    {
                        throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UnknownBooleanValue(value)));
                    }
                }
                else
                {
                    paramValue = value;
                }
            }
            else
            {
                throw Fx.AssertAndThrow("Unexpected attribute parameter type");
            }
            return paramValue;
        }
    }
}