using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using Tango.Core;
using Tango.Core.CustomAttributes;

/// <summary>
/// Contains extension methods for <see cref="IParameterized"/>.
/// </summary>
public static class IParameterizedExtensions
{
    /// <summary>
    /// Creates an observable collection of the parameterized object.
    /// </summary>
    /// <param name="instance">The instance.</param>
    /// <param name="mode">The parameters update mode.</param>
    /// <returns></returns>
    public static ObservableCollection<ParameterItem> CreateParametersCollection(this IParameterized instance, ParameterItemMode mode)
    {
        var ps = new ObservableCollection<ParameterItem>();

        int index = 0;

        List<Type> types = new List<Type>();
        Type currentType = instance.GetType();

        while (true)
        {
            if (typeof(IParameterized).IsAssignableFrom(currentType) && currentType != typeof(IParameterized))
            {
                types.Add(currentType);
                currentType = currentType.BaseType;
            }
            else
            {
                break;
            }
        }

        List<PropertyInfo> properties = new List<PropertyInfo>();

        foreach (var type in types)
        {
            foreach (var prop in type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Where(x => x.SetMethod != null))
            {
                if (prop.PropertyType.IsPrimitive || prop.PropertyType == typeof(String) || prop.PropertyType == typeof(DateTime))
                {
                    var paramAtt = prop.GetCustomAttributes(typeof(ParameterItemAttribute), false).Cast<ParameterItemAttribute>().FirstOrDefault();
                    var ignore = prop.GetCustomAttributes(typeof(ParameterIgnoreAttribute), false).Cast<ParameterIgnoreAttribute>().FirstOrDefault();
                    var indexAttr = prop.GetCustomAttributes(typeof(PropertyIndexAttribute), false).Cast<PropertyIndexAttribute>().FirstOrDefault();

                    if (ignore == null && !properties.Exists(x => x.Name == prop.Name))
                    {
                        var item = instance.CreateParameterItem(prop, paramAtt,indexAttr != null ? indexAttr.Index : index++, mode);
                        ps.Add(item);
                        properties.Add(prop);
                    }
                }
            }
        }

        return ps.OrderBy(x => x.Index).ToObservableCollection();
    }

    /// <summary>
    /// Creates the parameter item.
    /// </summary>
    /// <param name="instance">The instance.</param>
    /// <param name="propertyInfo">The property information.</param>
    /// <param name="attribute">The attribute.</param>
    /// <param name="index">The index.</param>
    /// <param name="mode">The mode.</param>
    /// <returns></returns>
    public static ParameterItem CreateParameterItem(this IParameterized instance, PropertyInfo propertyInfo, ParameterItemAttribute attribute, int index, ParameterItemMode mode)
    {
        ParameterItem item = new ParameterItem();
        item.Name = propertyInfo.Name.ToTitle();
        item.Index = index;
        item.Type = propertyInfo.PropertyType;
        item.ParameterizedObject = instance;

        if (attribute != null)
        {
            item.Value = attribute.Default;
            item.Minimum = attribute.Minimum;
            item.Maximum = attribute.Maximum;
            item.CustomEditorTypeName = attribute.CustomEditorTypeName;
            item.ExtraObject = attribute.ExtraObject;

            if (attribute.Name != null)
            {
                item.Name = attribute.Name;
            }
        }
        else
        {
            //Try get description and range attributes
            DescriptionAttribute desAtt = propertyInfo.GetCustomAttribute<DescriptionAttribute>();
            if (desAtt != null)
            {
                item.Description = desAtt.Description;
            }

            RangeAttribute rangeAtt = propertyInfo.GetCustomAttribute<RangeAttribute>();
            if (rangeAtt != null)
            {
                item.Minimum = rangeAtt.Minimum;
                item.Maximum = rangeAtt.Maximum;
            }

            StringFormatAttribute formatAtt = propertyInfo.GetCustomAttribute<StringFormatAttribute>();
            if (formatAtt != null)
            {
                item.StringFormat = formatAtt.Format;
            }

            PropertyIndexAttribute indexAtt = propertyInfo.GetCustomAttribute<PropertyIndexAttribute>();
            if (indexAtt != null)
            {
                item.Index = indexAtt.Index;
            }
        }

        if (mode == ParameterItemMode.Event)
        {
            item.ParameterValueChanged += (sender, e) =>
            {
                propertyInfo.SetValue(instance, e.Value);
            };
        }
        else if (mode == ParameterItemMode.Binding)
        {
            item.Bind(ParameterItem.ValueProperty, instance, propertyInfo.Name, System.Windows.Data.BindingMode.TwoWay);
        }


        return item;
    }

    /// <summary>
    /// Creates the parameter item.
    /// </summary>
    /// <param name="instance">The instance.</param>
    /// <param name="propertyName">Name of the property.</param>
    /// <param name="attribute">The attribute.</param>
    /// <param name="index">The index.</param>
    /// <param name="mode">The mode.</param>
    /// <returns></returns>
    public static ParameterItem CreateParameterItem(this IParameterized instance, String propertyName, ParameterItemAttribute attribute, int index, ParameterItemMode mode)
    {
        return instance.CreateParameterItem(instance.GetType().GetProperty(propertyName), attribute, index, mode);
    }
}