using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Web.DynamicData.Util;
using System.Web.Resources;
using System.Web.Routing;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace System.Web.DynamicData {
    internal static class Misc {
        public static HttpContextWrapper ToWrapper(this HttpContext context) {
            return new HttpContextWrapper(context);
        }

        public static object GetRealDataItem(object dataItem) {
            if (dataItem is ICustomTypeDescriptor) {
                // Unwrap EF object
                dataItem = ((ICustomTypeDescriptor)dataItem).GetPropertyOwner(null);
            }
            return dataItem;
        }

        // Walks the type hierachy up to endingType (assuming startingType is a subtype of starting type)
        // trying to find a meta table.
        public static MetaTable GetTableFromTypeHierarchy(Type entityType) {
            if (entityType == null) {
                throw new ArgumentNullException("entityType");
            }

            Type type = entityType;
            while (type != null) {
                MetaTable table;
                if (MetaTable.TryGetTable(type, out table)) {
                    return table;
                }
                type = type.BaseType;
            }

            return null;
        }

        public static Type RemoveNullableFromType(Type type) {
            return Nullable.GetUnderlyingType(type) ?? type;
        }

        internal static bool IsColumnInDictionary(IMetaColumn column, IDictionary<string, object> values) {
            if (column == null) {
                throw new ArgumentNullException("column");
            }
            if (values == null) {
                throw new ArgumentNullException("values");
            }
            IMetaForeignKeyColumn foreignKeyColumn = column as IMetaForeignKeyColumn;
            if (foreignKeyColumn != null) {
                return foreignKeyColumn.ForeignKeyNames.All(fkName => values.ContainsKey(fkName));
            }
            return values.ContainsKey(column.Name);
        }

        internal static IDictionary<string, object> ConvertObjectToDictionary(object instance) {
            if (instance == null) {
                throw new ArgumentNullException("instance");
            }
            Dictionary<string, object> values = new Dictionary<string, object>();
            var props = TypeDescriptor.GetProperties(instance);
            foreach (PropertyDescriptor p in props) {
                values[p.Name] = p.GetValue(instance);
            }
            return values;
        }

        public static T ChangeType<T>(object value) {
            return (T)ChangeType(value, typeof(T));
        }

        public static object ChangeType(object value, Type type) {
            if (type == null) {
                throw new ArgumentNullException("type");
            }

            if (value == null) {
                if (TypeAllowsNull(type)) {
                    return null;
                }
                return Convert.ChangeType(value, type, CultureInfo.CurrentCulture);
            }

            type = RemoveNullableFromType(type);

            if (value.GetType() == type) {
                return value;
            }

            TypeConverter converter = TypeDescriptor.GetConverter(type);
            if (converter.CanConvertFrom(value.GetType())) {
                return converter.ConvertFrom(value);
            }

            TypeConverter otherConverter = TypeDescriptor.GetConverter(value.GetType());
            if (otherConverter.CanConvertTo(type)) {
                return otherConverter.ConvertTo(value, type);
            }

            throw new InvalidOperationException(String.Format(
                            CultureInfo.CurrentCulture,
                            DynamicDataResources.Misc_CannotConvertType, value.GetType(), type));
        }

        internal static bool TypeAllowsNull(Type type) {
            return Nullable.GetUnderlyingType(type) != null || !type.IsValueType;
        }

        public static ContainerType FindContainerType(Control control) {
            if (control == null) {
                throw new ArgumentNullException("control");
            }

            Control container = control;
            // Walk up NamingContainers until we find one of the DataBound control interfaces
            while (container != null) {
                if (container is IDataBoundItemControl) {
                    return ContainerType.Item;
                }
                else if (container is IDataBoundListControl || container is Repeater) {
                    return ContainerType.List;
                }
                container = container.NamingContainer;
            }
            // Default container type is a list if none of the known 
            // interfaces are found
            return ContainerType.List;
        }

        public static IOrderedDictionary GetEnumNamesAndValues(Type enumType) {
            Debug.Assert(enumType != null);
            Debug.Assert(enumType.IsEnum);
            OrderedDictionary result = new OrderedDictionary();
            var enumEntries = from e in Enum.GetValues(enumType).OfType<object>()
                              select new EnumEntry {
                                  // 
                                  Name = Enum.GetName(enumType, e),
                                  UnderlyingValue = GetUnderlyingTypeValue(enumType, e)
                              };
            foreach (var entry in enumEntries.OrderBy(e => e.UnderlyingValue)) {
                result.Add(entry.Name, entry.UnderlyingValue.ToString());
            }
            return result;
        }

        private struct EnumEntry {
            public string Name { get; set; }
            public object UnderlyingValue { get; set; }
        }

        public static object GetUnderlyingTypeValue(Type enumType, object enumValue) {
            return Convert.ChangeType(enumValue, Enum.GetUnderlyingType(enumType), CultureInfo.InvariantCulture);
        }

        public static string GetUnderlyingTypeValueString(Type enumType, object enumValue) {
            return GetUnderlyingTypeValue(enumType, enumValue).ToString();
        }

        public static string PersistListToCommaSeparatedString(IList<object> list) {
            // Special case empty and single lists
            if (list == null || list.Count == 0)
                return String.Empty;
            if (list.Count == 1) {
                return list[0] == null ? String.Empty : list[0].ToString().TrimEnd();
            }

            var builder = new StringBuilder();
            bool first = true;
            bool hasNonNullItem = false;
            foreach (object o in list) {
                if (!first) {
                    builder.Append(",");
                }

                if (o != null) {
                    // 
                    builder.Append(o.ToString().TrimEnd());

                    hasNonNullItem = true;
                }
                first = false;
            }

            // If all the parts are null, return empty string instead of the comma separated list
            if (!hasNonNullItem)
                return String.Empty;

            return builder.ToString();
        }

        // 
        public static object[] GetKeyValues(IList<MetaColumn> keyMembers, object entity) {
            object[] values = new object[keyMembers.Count];

            int index = 0;
            foreach (MetaColumn pkMember in keyMembers) {
                values[index++] = DataBinder.GetPropertyValue(entity, pkMember.Name);
            }

            return values;
        }

        public static string[] ParseCommaSeparatedString(string stringList) {
            // 
            return stringList.Split(',');
        }

        public static IQueryable BuildSortQueryable(IQueryable query, IMetaTable table) {
            IMetaColumn sortColumn = table.SortColumn;
            if (sortColumn.IsCustomProperty) {
                // An extra property can't be optimized on server
                // 
                var data = query.OfType<object>().AsEnumerable();
                Func<object, object> lambda = row => DataBinder.GetPropertyValue(row, sortColumn.Name);
                if (table.SortDescending) {
                    query = data.OrderByDescending<object, object>(lambda).AsQueryable();
                }
                else {
                    query = data.OrderBy<object, object>(lambda).AsQueryable();
                }
            }
            else {
                // Build custom expression to optimize sorting on server
                // 
                var parameter = Expression.Parameter(query.ElementType, "row");
                LambdaExpression lambda = null;
                IMetaForeignKeyColumn foreignKeyColumn = sortColumn as IMetaForeignKeyColumn;
                if (foreignKeyColumn != null) {
                    // e.g. product => product.Category.CategoryName
                    var foreignKeySortColumn = foreignKeyColumn.ParentTable.SortColumn;
                    lambda = Expression.Lambda(Expression.Property(Expression.Property(parameter, sortColumn.Name), foreignKeySortColumn.Name), parameter);
                }
                else {
                    // e.g. product => product.ProductName
                    lambda = Expression.Lambda(Expression.Property(parameter, sortColumn.Name), parameter);
                }
                string ordering = table.SortDescending ? "OrderByDescending" : "OrderBy";
                var expression = Expression.Call(typeof(Queryable), ordering, new Type[] { query.ElementType, lambda.Body.Type }, query.Expression, lambda);
                query = query.Provider.CreateQuery(expression);
            }
            return query;
        }

        // Fill a ListItemCollection with all the entries from a table
        public static void FillListItemCollection(IMetaTable table, ListItemCollection listItemCollection) {
            foreach (var o in table.GetQuery()) {
                string text = table.GetDisplayString(o);
                string value = table.GetPrimaryKeyString(o);
                listItemCollection.Add(new ListItem(text, value.TrimEnd()));
            }
        }

        internal static void ExtractValuesFromBindableControls(IOrderedDictionary dictionary, Control container) {
            IBindableControl bindableControl = container as IBindableControl;
            if (bindableControl != null) {
                bindableControl.ExtractValues(dictionary);
            }
            foreach (Control childControl in container.Controls) {
                ExtractValuesFromBindableControls(dictionary, childControl);
            }
        }

        /// <devdoc>
        /// Walks up the stack of NamingContainers starting at 'control' to find a control with the ID 'controlID'.
        /// Copied from DataBoundControlHelper.FindControl (System.Web)
        /// </devdoc>
        public static Control FindControl(Control control, string controlID) {
            Debug.Assert(control != null, "control should not be null");
            //Debug.Assert(!String.IsNullOrEmpty(controlID), "controlID should not be empty");
            Control currentContainer = control;
            Control foundControl = null;

            if (control == control.Page) {
                // If we get to the Page itself while we're walking up the
                // hierarchy, just return whatever item we find (if anything)
                // since we can't walk any higher.
                return control.FindControl(controlID);
            }

            while (foundControl == null && currentContainer != control.Page) {
                currentContainer = currentContainer.NamingContainer;
                if (currentContainer == null) {
                    throw new HttpException(String.Format(CultureInfo.CurrentCulture,
                            DynamicDataResources.Misc_NoNamingContainer,
                            control.GetType().Name, control.ID));
                }
                foundControl = currentContainer.FindControl(controlID);
            }

            return foundControl;
        }

        public static string GetRouteValue(string key) {
            RequestContext requestContext = DynamicDataRouteHandler.GetRequestContext(HttpContext.Current);
            object value;
            if (!requestContext.RouteData.Values.TryGetValue(key, out value)) {
                return null;
            }

            return value as string;
        }

        public static string SanitizeQueryStringValue(object value) {
            if (value == null)
                return null;

            string strValue = value.ToString();

            // Trim trailing spaces, as they are typically meaningless, and make the url look ugly
            return strValue.TrimEnd();
        }

        internal static long CombineHashCodes(object o1, object o2) {
            // Start with a seed (obtained from String.GetHashCode implementation)
            long combinedHash = 5381;

            combinedHash = AddHashCode(combinedHash, o1);
            combinedHash = AddHashCode(combinedHash, o2);

            return combinedHash;
        }

        // Return a single hash code for 3 objects
        internal static long CombineHashCodes(object o1, object o2, object o3) {
            // Start with a seed (obtained from String.GetHashCode implementation)
            long combinedHash = 5381;

            combinedHash = AddHashCode(combinedHash, o1);
            combinedHash = AddHashCode(combinedHash, o2);
            combinedHash = AddHashCode(combinedHash, o3);

            return combinedHash;
        }

        private static long AddHashCode(long currentHash, object o) {
            if (o == null)
                return currentHash;

            return ((currentHash << 5) + currentHash) ^ o.GetHashCode();
        }
    }
}