//------------------------------------------------------------------------------
// <copyright file="PropertyMapper.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

/*
 * PropertyMapper.cs
 *
 * Copyright (c) 1999 Microsoft Corporation
 */

namespace System.Web.UI {
    using System;
    using System.Collections;
    using System.Reflection;
    using System.Web.Util;
    using System.ComponentModel;

    internal sealed class PropertyMapper {
        private const char PERSIST_CHAR = '-';
        private const char OM_CHAR = '.';
        private const string STR_OM_CHAR = ".";


        /*
         * Maps persisted attribute names to the object model equivalents.
         * This class should not be instantiated by itself.
         */
        private PropertyMapper() {
        }

        /*
         * Returns the PropertyInfo or FieldInfo corresponding to the
         * specified property name.
         */
        internal static MemberInfo GetMemberInfo(Type ctrlType, string name, out string nameForCodeGen) {

            Type currentType = ctrlType;
            PropertyInfo propInfo = null;
            FieldInfo fieldInfo = null;

            string mappedName = MapNameToPropertyName(name);
            nameForCodeGen = null;

            int startIndex = 0;
            while (startIndex < mappedName.Length) {   // parse thru dots of object model to locate PropertyInfo
                string propName;
                int index = mappedName.IndexOf(OM_CHAR, startIndex);

                if (index < 0) {
                    propName = mappedName.Substring(startIndex);
                    startIndex = mappedName.Length;
                }
                else {
                    propName = mappedName.Substring(startIndex, index - startIndex);
                    startIndex = index + 1;
                }

                BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.IgnoreCase;

                // 



                try {
                    propInfo = TargetFrameworkUtil.GetProperty(currentType, propName, flags);
                }
                catch (AmbiguousMatchException) {
                    flags |= BindingFlags.DeclaredOnly;
                    propInfo = TargetFrameworkUtil.GetProperty(currentType, propName, flags);
                }

                if (propInfo == null) {   // could not find a public property, look for a public field
                    fieldInfo = TargetFrameworkUtil.GetField(currentType, propName, flags);
                    if (fieldInfo == null) {
                        nameForCodeGen = null;
                        break;
                    }
                }

                propName = null;
                if (propInfo != null) {   // found a public property
                    currentType = propInfo.PropertyType;
                    propName = propInfo.Name;
                }
                else {   // found a public field
                    currentType = fieldInfo.FieldType;
                    propName = fieldInfo.Name;
                }

                // Throw if the type of not CLS-compliant (ASURT 83438)
                if (!IsTypeCLSCompliant(currentType)) {
                    throw new HttpException(SR.GetString(SR.Property_Not_ClsCompliant, name, ctrlType.FullName, currentType.FullName));
                }

                if (propName != null) {
                    if (nameForCodeGen == null)
                        nameForCodeGen = propName;
                    else
                        nameForCodeGen += STR_OM_CHAR + propName;
                }
            }

            if (propInfo != null)
                return propInfo;
            else
                return fieldInfo;
        }

        private static bool IsTypeCLSCompliant(Type type) {

            // We used to check this by looking up the CLSCompliantAttribute, but that was
            // way too inefficent.  So instead, we just juck for a few specific types
            if ((type == typeof(SByte)) ||
                (type == typeof(TypedReference)) ||
                (type == typeof(UInt16)) ||
                (type == typeof(UInt32)) ||
                (type == typeof(UInt64)) ||
                (type == typeof(UIntPtr))) {
                return false;
            }

            return true;
        }

        /*
         * Maps the specified persisted name to its object model equivalent.
         * The convention is to map all dashes to dots.
         * For example :  Font-Size maps to Font.Size
         *                HeaderStyle-Font-Name maps to HeaderStyle.Font.Name
         */
        internal static string MapNameToPropertyName(string attrName) {
            return attrName.Replace(PERSIST_CHAR,OM_CHAR);
        }

        internal static object LocatePropertyObject(object obj, string mappedName, out string propertyName, bool inDesigner) {
            object currentObject = obj;
            Type currentType = obj.GetType();
            propertyName = null;
            int index;
            int startIndex = 0;

            // step through the dots of the object model to extract the PropertyInfo
            // and object on which the property will be set
            while (startIndex < mappedName.Length) {
                index = mappedName.IndexOf(OM_CHAR, startIndex);

                // If we didn't find a separator, we're on the last piece
                if (index < 0)
                    break;

                // There is a sub property, so get its info and iterate

                propertyName = mappedName.Substring(startIndex, index - startIndex);
                startIndex = index + 1;

                currentObject = FastPropertyAccessor.GetProperty(currentObject, propertyName, inDesigner);

                if (currentObject == null)
                    return null;
            }

            // Avoid a useless call to Substring if possible
            if (startIndex > 0)
                propertyName = mappedName.Substring(startIndex);
            else
                propertyName = mappedName;

            return currentObject;
        }

        /*
         * Walks the object model using the mapped property name to get the
         * value of an instance's property.
         */
        internal static PropertyDescriptor GetMappedPropertyDescriptor(object obj, string mappedName, out object childObject, out string propertyName, bool inDesigner)
        {
            childObject = LocatePropertyObject(obj, mappedName, out propertyName, inDesigner);
            if (childObject == null) return null;
            PropertyDescriptorCollection properties = TargetFrameworkUtil.GetProperties(childObject);
            return properties[propertyName];
        }


        /*
         * Walks the object model using the mapped property name to set the
         * value of an instance's property.
         */
        internal static void SetMappedPropertyValue(object obj, string mappedName, object value, bool inDesigner) {
            string propertyName;
            object childObj = LocatePropertyObject(obj, mappedName, out propertyName, inDesigner);
            if (childObj == null) return;
            FastPropertyAccessor.SetProperty(childObj, propertyName, value, inDesigner);
        }

    }
}