using OpenTap;
using OpenTap.Addin.Annotation;
using OpenTapEditor.UI;
using System.ComponentModel;
using System.Windows.Controls;
using System.Windows.Data;
using System.Xml.Serialization;

namespace OpenTapEditor.Provider
{
    public class DutControlProvider
    {
        private static ITypeData resourceTypeData = TypeData.FromType(typeof(IResource));


        public static object? GetItemValue(AnnotationCollection x)
        {
            return (x.Get<IAvailableValuesAnnotation>() as IStringReadOnlyValueAnnotation)?.Value
                                ?? x.Get<IStringValueAnnotation>()?.Value
                                ?? x.Get<IStringReadOnlyValueAnnotation>()?.Value
                                ?? x.Get<IAvailableValuesAnnotationProxy>()?.SelectedValue?.Source?.ToString()
                                ?? x.Get<IObjectValueAnnotation>()?.Value;
        }

        public static AnnotationCollection[]? getMembers(AnnotationCollection annotations)
        {
            return annotations?.Get<IMembersAnnotation>()?.Members
                .Where(x =>
                {
                    var member = x.Get<IMemberAnnotation>().Member;
                    if (member.DeclaringType.DescendsTo(TypeData.FromType(typeof(IResource))) && member.Name == nameof(Resource.Name))
                        return true;

                    return x.Get<IAccessAnnotation>()?.IsVisible ?? false;
                })
                .Where(x =>
                {
                    var member = x.Get<IMemberAnnotation>()?.Member;
                    if (member == null || (member.GetAttribute<SubmitAttribute>() != null && x.Get<IAvailableValuesAnnotationProxy>() != null)) return false;
                    return FilterMember(member);
                })
                .ToArray();
        }

        public static StackPanel test(AnnotationCollection annotation)
        {
            var valueAnnotation = annotation.Get<IObjectValueAnnotation>();
            if (valueAnnotation == null) return null;
            StackPanel stack = new StackPanel()
            {
                Orientation = Orientation.Horizontal
            };
            stack.Children.Add(new TextBlock { Text = annotation.Get<DisplayAttribute>().Name });

            /// 列表
            if (annotation.Get<ICollectionAnnotation>() is ICollectionAnnotation caa)
            {
                if (annotation.Get<ReadOnlyMemberAnnotation>() != null) return null;
                var fixedSize = annotation.Get<IFixedSizeCollectionAnnotation>()?.IsFixedSize ?? false;
                var items = caa.AnnotatedElements.Select(a => a.Source).ToArray();
                var dataType = caa.AnnotatedElements.GetType();
                //Type genericArgument = dataType.GetGenericArguments()[0];

                bool placeholderElementAdded = false;
                var dataGrid = new DataGrid();

                if (annotation.Get<BindingListAttribute>() is BindingListAttribute bla)
                {
                    BindingOperations.SetBinding(dataGrid,
                        DataGrid.ItemsSourceProperty,
                        new Binding(bla.BindingName)
                        {
                            Source = annotation.Source,
                            Mode = BindingMode.TwoWay,
                        });
                    dataGrid.CanUserAddRows = bla.CanAdd;
                    dataGrid.AutoGenerateColumns = false;

                    Type propertyType = annotation?.Source?.GetType()?.GetProperty(bla.BindingName)?.PropertyType;
                    if (propertyType?.IsGenericType == true)
                    {
                        DataGridHelper.SetDataGridColumns(dataGrid, propertyType.GetGenericArguments()[0]);
                    }
                    else
                    {
                        DataGridHelper.SetDataGridColumns(dataGrid, propertyType);
                    }
                }
                else
                {
                    dataGrid.ItemsSource = items;
                }
                stack.Children.Add(dataGrid);
                return stack;
            }

            // StringValue是正常的输入
            // IAvailableValuesAnnotation 是枚举
            // IStringReadOnlyValueAnnotation是只读
            var stringValueAnnotation = annotation.Get<IStringValueAnnotation>();
            if (stringValueAnnotation == null) return null;

            var selectAnnotation = annotation.Get<IAvailableValuesAnnotationProxy>();
            if (selectAnnotation != null)
            {
                var source = selectAnnotation.AvailableValues;
                var comboBox = new ComboBox
                {
                    DisplayMemberPath = "Source.Name",
                    ItemsSource = source
                };
                BindingOperations.SetBinding(comboBox, ComboBox.SelectedItemProperty,

                new Binding(nameof(IAvailableValuesAnnotationProxy.SelectedValue))
                {
                    Source = selectAnnotation,
                    Mode = BindingMode.TwoWay,
                    NotifyOnSourceUpdated = true,
                });
                comboBox.SourceUpdated += (sender, e) =>
                {
                    annotation.Write();
                    annotation.Read();
                };
                stack.Children.Add(comboBox);
                return stack;
            }

            if (annotation.Get<FilePathAttribute>() is FilePathAttribute fpa)
            {
                FileSelector fs = new FileSelector();
                stack.Children.Add(fs);
                BindingOperations.SetBinding(fs, FileSelector.FilePathProperty,
                    new Binding(nameof(IStringValueAnnotation.Value))
                    {
                        Source = stringValueAnnotation,
                        Mode = BindingMode.TwoWay,
                        NotifyOnSourceUpdated = true
                    });
                fs.SourceUpdated += (sender, e) =>
                {
                    annotation.Write();
                    annotation.Read();
                };
                return stack;
            }


            if (annotation.Get<DynamicSelectAttribute>() is DynamicSelectAttribute dsa)
            {
                ComboBox combox = new ComboBox();
                stack.Children.Add(combox);

                BindingOperations.SetBinding(combox, ComboBox.ItemsSourceProperty,
                    new Binding(dsa.SourceName)
                    {
                        Source = dsa,
                        Mode = BindingMode.OneWay
                    });

                BindingOperations.SetBinding(combox, ComboBox.TextProperty,
                new Binding(nameof(stringValueAnnotation.Value))
                {
                    Source = stringValueAnnotation,
                    Mode = BindingMode.TwoWay,
                    NotifyOnSourceUpdated = true
                });
                combox.SourceUpdated += (sender, e) =>
                {
                    annotation.Write();
                    annotation.Read();
                };
                return stack;
            }

            TextBox tb = new TextBox();
            stack.Children.Add(tb);
            BindingOperations.SetBinding(tb, TextBox.TextProperty,
                new Binding(nameof(IStringValueAnnotation.Value))
                {
                    Source = stringValueAnnotation,
                    Mode = BindingMode.TwoWay,
                    NotifyOnSourceUpdated = true
                });
            tb.SourceUpdated += (sender, e) =>
            {
                annotation.Write();
                annotation.Read();
            };

            //var update = annotation.Get<UpdateMonitor>(true);
            //if (update != null)
            //{
            //    update.RegisterSourceUpdated(tb, () => tb.GetBindingExpression(TextBox.TextProperty).UpdateTarget());
            //}
            return stack;
        }

        public static bool FilterMember(IMemberData member)
        {
            if (member.DeclaringType.DescendsTo(resourceTypeData) && member.Name == nameof(Resource.Name))
                return true;
            if (member.GetAttribute<BrowsableAttribute>() is BrowsableAttribute attr)
                return attr.Browsable;
            if (member.HasAttribute<OutputAttribute>())
                return true;
            return member.Attributes.Any(a => a is XmlIgnoreAttribute) == false && member.Writable;
        }

        public static StackPanel GetControl(AnnotationCollection annotation)
        {
            var stack = new StackPanel()
            {

            };

            var groupCache = new Dictionary<string, Expander>();

            Expander GetExpander(List<string> groups)
            {
                Expander groupNode = null;
                Expander lastGroup = null;
                string groupKey = null;
                foreach (var group in groups)
                {
                    groupKey = string.IsNullOrEmpty(groupKey) ? group : (groupKey + "." + group);
                    groupNode = null;
                    if (groupCache.TryGetValue(groupKey, out groupNode) == false)
                    {
                        // add the group
                        groupNode = new Expander
                        {
                            IsExpanded = true,
                            Header = groupKey,
                            Content = new StackPanel()
                        };
                        groupCache[groupKey] = groupNode;

                        if (lastGroup != null)
                        {
                            ((StackPanel)lastGroup.Content).Children.Add(groupNode);
                        }
                        else
                        {
                            stack.Children.Add(groupNode);
                        }
                    }
                    lastGroup = groupNode;
                }
                return groupNode;
            }

            var members = getMembers(annotation);
            foreach (var ann in members)
            {
                var control = test(ann);
                if (control == null) continue;
                var _groups = ann?.Get<DisplayAttribute>().Group.ToList();
                if (_groups == null || _groups.Count <= 0)
                {
                    stack.Children.Add(control);
                }
                else
                {
                    var expander = GetExpander(_groups);
                    ((StackPanel)expander.Content).Children.Add(control);
                }
            }
            return stack;
        }
    }
}