using Autodesk.Revit.DB;
using Autodesk.Revit.UI;

using System;
using System.Windows;

using Szmedi.RvKits.Models;

namespace Szmedi.RvKits.TransmitFamily
{
    /// <summary>
    ///     FamilyTransmit.xaml 的交互逻辑
    /// </summary>
    public partial class TransmitProjectWin 
    {
        private readonly IList<TreeModel> familyNodes = new List<TreeModel>();
        private readonly List<DocumentItem> docsFromListWpf = new();
        private readonly List<DocumentItem> docsToListWpf = new();

        private readonly UIApplication uiapp;

        //便于类中各处进行调用，故在此处添加字段
        //private doc doc;

        private readonly UIDocument uidoc;
        private Document docFrom;
        private Document docTo;
        private string docFromName;
        private string docToName;

        /// <summary>
        ///     构造
        /// </summary>
        public TransmitProjectWin()
        {
            InitializeComponent();
        }

        /// <summary>
        ///     重载，参数传入窗体
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="uidoc"></param>
        /// <param name="uiapp"></param>
        public TransmitProjectWin(UIApplication uiapp)
        {
            this.uiapp = uiapp;
            uidoc = uiapp.ActiveUIDocument;
            InitializeComponent();
            ListOfOpenedDocument();
        }

        /// <summary>
        ///     获取族，并将族列表绑定到TreeVIew控件
        /// </summary>
        private void AddFamilyToTreeView()
        {
            try
            {
                foreach (Document selectedDoc in uiapp.Application.Documents)
                {
                    if (!selectedDoc.IsLinked && !selectedDoc.IsFamilyDocument)
                    {
                        if (cbbFrom.SelectedValue.ToString() == selectedDoc.Title)
                        {
                            List<TreeModel> familiesTree = new();

                            #region 族

                            Categories categories = selectedDoc.Settings.Categories;

                            var familyCollector = new FilteredElementCollector(selectedDoc).OfClass(typeof(Family));

                            var familySymbolCollector = new FilteredElementCollector(selectedDoc).OfClass(typeof(FamilySymbol));

                            //List<ElementId> dimensionTypeId = (from Element i in new FilteredElementCollector(selectedDoc).QueryElementsByType(typeof(DimensionType)) select i.Id).ToList();
                            //var elementTypes = new FilteredElementCollector(selectedDoc).QueryElementsByType(typeof(TypeName));

                            //ElementClassFilter familysymbolfilter = new ElementClassFilter(typeof(FamilySymbol));
                            //ElementClassFilter hostsymbolFilter = new ElementClassFilter(typeof(HostObjAttributes));
                            //LogicalOrFilter andfilter = new LogicalOrFilter(familysymbolfilter, hostsymbolFilter);
                            //var familiesSymbolCollector = new FilteredElementCollector(selectedDoc).WherePasses(andfilter);
                            foreach (Category category in categories)
                            {
                                TreeModel familyCategoryNode =
                                    new()
                                    {
                                        //familyCategory.Id = category.Name;
                                        Name = category.Name,
                                        IsExpanded = false
                                    };

                                foreach (Family family in familyCollector)
                                {
                                    if (family.FamilyCategory.Name == category.Name)
                                    {
                                        TreeModel familyNode =
                                            new()
                                            {
                                                //familyNode.Id = family.Name;
                                                Name = family.Name,
                                                IsExpanded = false,
                                                Parent = familyCategoryNode
                                            };
                                        familyCategoryNode.Children.Add(familyNode);

                                        //获取族及其族类型,作为加载对象合集
                                        familyNodes.Add(familyNode);
                                        foreach (FamilySymbol familySymbol in familySymbolCollector)
                                        {
                                            if (familySymbol.FamilyName == family.Name)
                                            {
                                                TreeModel familySymbolNode =
                                                    new()
                                                    {
                                                        //familiesSymbolNode.Id = familySymbol.Name;
                                                        Name = familySymbol.Name,
                                                        Parent = familyNode
                                                    };
                                                familyNode.Children.Add(familySymbolNode);
                                            }
                                        }
                                    }
                                }

                                if (familyCategoryNode.Children.Count != 0)
                                {
                                    familiesTree.Add(familyCategoryNode);
                                }
                            }

                            #endregion 族

                            var hostObjectCollector = new FilteredElementCollector(selectedDoc).OfClass(typeof(HostObjAttributes));
                            //IList<string> categoryNames = (from HostObjAttributes ele in hostObjectCollector
                            //                               select ele.Category.Name).ToList();

                            //var elementTypes = new FilteredElementCollector(selectedDoc).QueryElementsByType(typeof(TypeName));
                            //List<string> ss1 = categoryNames.Distinct().ToList();
                            foreach (HostObjAttributes obj in hostObjectCollector)
                            {
                                string categoryName = obj.Category.Name;
                                string familyName = obj.FamilyName;
                                string familySymbolName = obj.Name;

                                #region categoryRegion

                                TreeModel familyCategoryNode = null;
                                foreach (var t in familiesTree)
                                {
                                    if (t.ToolTip.Equals(categoryName)) //遍历是否找到相同的节点
                                    {
                                        familyCategoryNode = t; //有则传递给当前类别节点
                                        break;
                                    }
                                }

                                if (familyCategoryNode == null)
                                {
                                    TreeModel t = new() { Name = categoryName, IsExpanded = false };

                                    familyCategoryNode = t;
                                    familiesTree.Add(familyCategoryNode);
                                }

                                #endregion categoryRegion

                                #region familyRegion

                                TreeModel familyNode = null;
                                foreach (var t in familyCategoryNode.Children)
                                {
                                    if (t.ToolTip.Equals(categoryName + "-" + familyName))
                                    {
                                        familyNode = t;
                                        break;
                                    }
                                }

                                if (familyNode == null)
                                {
                                    TreeModel t =
                                        new()
                                        {
                                            Name = familyName,
                                            IsExpanded = false,
                                            Parent = familyCategoryNode
                                        };
                                    familyCategoryNode.Children.Add(t);

                                    familyNode = t;

                                    familyNodes.Add(familyNode);
                                }

                                #endregion familyRegion

                                #region familySymbol

                                TreeModel familySymbolNode = null;
                                foreach (var t in familyNode.Children)
                                {
                                    if (t.ToolTip.Equals(familyName + "-" + familySymbolName))
                                    {
                                        familySymbolNode = t;
                                        break;
                                    }
                                }

                                if (familySymbolNode == null)
                                {
                                    TreeModel t =
                                        new()
                                        {
                                            Name = familySymbolName,
                                            IsExpanded = false,
                                            Parent = familyNode
                                        };
                                    familyNode.Children.Add(t);
                                }

                                #endregion familySymbol

                                //TreeModel familyNode = new TreeModel();
                                //familyNode.Name = obj.FamilyName;
                                ////familyNode.Name = obj.FamilyName;
                                //familyNode.IsExpanded = false;
                                //familyNode.Parent = categoryNode;
                                //categoryNode.Children.Add(familyNode);

                                //familyNodes.Add(familyNode);
                                ////if (obj.Name == familyNode.Name)
                                ////{
                                //TreeModel familiesSymbolNode = new TreeModel();
                                ////familiesSymbolNode.Id = familySymbol.Name;
                                //familiesSymbolNode.Name = obj.Name;
                                //familiesSymbolNode.Parent = familyNode;
                                //familyNode.Children.Add(familiesSymbolNode);
                                //}
                            }

                            familiesTree.Sort();

                            FamilyTreeView.ItemsSourceData = familiesTree;
                            //FamilyTreeView.UpdateLayout();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }

        private void btnClose_Click(object sender, RoutedEventArgs e)
        {
            Close();
        }

        private void btnTransmit_Click(object sender, RoutedEventArgs e)
        {
            Close();
            IList<TreeModel> selectedItems = FamilyTreeView.CheckedItemsIgnoreRelation();

            if (selectedItems.Count == 0)
            {
                MessageBox.Show("请选择需要传递的族");
            }
            else
            {
                UIDocument uidoc = this.uidoc;
                Autodesk.Revit.ApplicationServices.Application app = uiapp.Application;

                IList<ElementId> transmitIds = new List<ElementId>();
                foreach (Document doc in app.Documents)
                {
                    if (!doc.IsLinked)
                    {
                        if (doc.Title == docToName)
                        {
                            docTo = doc;
                        }

                        if (doc.Title == docFromName)
                        {
                            docFrom = doc;
                        }
                    }
                }

                //ElementClassFilter familysymbolfilter = new ElementClassFilter(typeof(FamilySymbol));
                //ElementClassFilter hostsymbolFilter = new ElementClassFilter(typeof(HostObjAttributes));
                //LogicalOrFilter andfilter = new LogicalOrFilter(familysymbolfilter, hostsymbolFilter);
                //var familiesSymbolCollector = new FilteredElementCollector(doc).WherePasses(andfilter);

                var familiesSymbolCollector = new FilteredElementCollector(docFrom).OfClass(typeof(FamilySymbol));
                var hostObjSymbolCollector = new FilteredElementCollector(docFrom).OfClass(typeof(HostObjAttributes));

                foreach (TreeModel familyNode in familyNodes)
                {
                    if (familyNode.IsChecked != false)
                    {
                        foreach (TreeModel item in familyNode.Children)
                        {
                            if (item.IsChecked == true)
                            {
                                foreach (FamilySymbol familySymbol in familiesSymbolCollector)
                                {
                                    if (familySymbol.Name == item.Name && familySymbol.FamilyName == item.Parent.Name)
                                    {
                                        transmitIds.Add(familySymbol.Id);
                                    }
                                }

                                foreach (HostObjAttributes hostObjSymbol in hostObjSymbolCollector)
                                {
                                    if (hostObjSymbol.Name == item.Name && hostObjSymbol.FamilyName == item.Parent.Name)
                                    {
                                        transmitIds.Add(hostObjSymbol.Id);
                                    }
                                }
                            }
                        }
                    }
                }


                CopyPasteOptions copyPasteOptions = new();
                //if (rbOverride.IsChecked == true)
                //{
                //    copyPasteOptions.SetDuplicateTypeNamesHandler(new CopyHandlerOk());
                //}
                //else if (rbSkip.IsChecked == true)
                //{
                //    copyPasteOptions.SetDuplicateTypeNamesHandler(new CopyHandlerAbort());
                //}
                //else
                //{
                //}
                using Transaction trans = new(docTo);
                trans.Start("传递族");
                var options = trans.GetFailureHandlingOptions().SetFailuresPreprocessor(new FailuresPreProcessor());
                ElementTransformUtils.CopyElements(docFrom, transmitIds, docTo, null, copyPasteOptions);
                trans.Commit();
            }
        }

        private void cbbFrom_DropDownClosed(object sender, EventArgs e)
        {
            if (docsFromListWpf.Count > 1)
            {
                cbbTo.IsEnabled = true;
            }

            try
            {
                if (cbbFrom.SelectedItem != null)
                {
                    docsToListWpf.Clear();
                    cbbTo.ItemsSource = null;
                    foreach (var item in docsFromListWpf)
                    {
                        if (item != cbbFrom.SelectedItem)
                        {
                            docsToListWpf.Add(item);
                        }
                        else
                        {
                            docFromName = item.Name;
                        }
                    }

                    cbbTo.ItemsSource = docsToListWpf;
                    AddFamilyToTreeView();
                    FamilyTreeView.IsEnabled = true;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }

        private void cbbFrom_DropDownOpened(object sender, EventArgs e)
        {
            ListOfOpenedDocument();
        }

        private void cbbTo_DropDownClosed(object sender, EventArgs e)
        {
            if (cbbTo.SelectedItem == null) { }
            else
            {
                foreach (var item in docsToListWpf)
                {
                    if (item == cbbTo.SelectedItem)
                    {
                        docToName = item.Name;
                    }
                }

                btnTransmit.IsEnabled = true;
            }
        }

        private void ListOfOpenedDocument()
        {
            //docsFromListWpf.Clear();
            //cbbFrom.ItemsSource = null;
            foreach (Document document in uiapp.Application.Documents)
            {
                if (!document.IsLinked && !document.IsFamilyDocument)
                {
                    DocumentItem docItem = new(document.Title, document.Title);
                    //docItem.Name = doc.Title;
                    //docItem.Value = doc.Title;
                    docsFromListWpf.Add(docItem);
                }
            }

            cbbFrom.ItemsSource = docsFromListWpf;
        }

        /// <summary>
        ///     窗体加载时出发
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void WpfTransmit_Loaded(object sender, RoutedEventArgs e)
        {
            cbbTo.IsEnabled = false;
            FamilyTreeView.IsEnabled = false;
            btnTransmit.IsEnabled = false;
        }

        public class DocumentItem
        {
            public string Name { get; set; }

            public string Value { get; set; }

            public DocumentItem(string _Name, string _Value)
            {
                Name = _Name;
                Value = _Value;
            }

            public override string ToString()
            {
                return Name;
            }
        }

        //private int GetFamilyCount(IList<TreeModel> treeList)
        //{
        //    StringBuilder names = new StringBuilder();
        //    int number = 0;
        //    foreach (TreeModel tree in treeList)
        //    {
        //        if (tree.Children.Count == 0)
        //        {
        //            number++;
        //        }
        //    }
        //    return number;
        //}

        //private string GetNames(IList<TreeModel> treeList)
        //{
        //    StringBuilder names = new StringBuilder();

        //    foreach (TreeModel tree in treeList)
        //    {
        //        names.Append(tree.Name).Append(",");
        //    }
        //    return names.ToString();
        //}
    }

    //public class CopyHandlerOk : IDuplicateTypeNamesHandler
    //{
    //    public DuplicateTypeAction OnDuplicateTypeNamesFound(DuplicateTypeNamesHandlerArgs args)
    //    {
    //        return DuplicateTypeAction.UseDestinationTypes;
    //    }
    //}

    //public class CopyHandlerAbort : IDuplicateTypeNamesHandler
    //{
    //    public DuplicateTypeAction OnDuplicateTypeNamesFound(DuplicateTypeNamesHandlerArgs args)
    //    {
    //        return DuplicateTypeAction.Abort;
    //    }
    //}
}