using HStation.RevitDev.Model.ModelEnum;
using HStation.RevitDev.RevitDataExport.Entity;
using HStation.RevitDev.RevitDataExport.Entity.ElementModels;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Windows.Controls;

namespace HStation.RevitDev.RevitDataExport.Utility
{
    public class WpfBindingUtils
    {
        public static Dictionary<RevitType, bool> InitCache { get; set; } = new Dictionary<RevitType, bool>();
        public static void Binding(DataGrid dataGrid, RevitType revitType, ObservableCollection<ElementModel> models)
        {
            if (!InitCache.ContainsKey(revitType))
            {
                InitCache.Add(revitType, false);
            }
            if (!InitCache[revitType])
            {
                InitDataGridColumns(dataGrid, revitType);
                InitCache[revitType] = true;
            }
        }

        public static void Binding2(DataGrid dataGrid, RevitType revitType, List<string> models)
        {
            switch (revitType)
            {
                case RevitType.RFT_Pump:
                    {
                        var subModels = ModelFactory.Convert2Sub<PumbModel2>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<PumbModel2>(dataGrid);
                        break;
                    }
                case RevitType.RFT_Blocker:
                    {
                        var subModels = ModelFactory.Convert2Sub<BlockerModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<BlockerModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_Converter:
                    {
                        var subModels = ModelFactory.Convert2Sub<ConvertorModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<ConvertorModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_Elbow:
                    {
                        var subModels = ModelFactory.Convert2Sub<ElbowModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<ElbowModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_FourJoint:
                    {
                        var subModels = ModelFactory.Convert2Sub<SiTongModel>(models);
                        dataGrid.ItemsSource = subModels; 
                        //HeaderConvertChs<SiTongModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_HeatExchanger:
                    {
                        var subModels = ModelFactory.Convert2Sub<HeatExchangerModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<HeatExchangerModel>(dataGrid);
                        break;
                    }

                case RevitType.RFT_Pipe:
                    {
                        var subModels = ModelFactory.Convert2Sub<PipeModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<PipeModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_Shower:
                    {
                        var subModels = ModelFactory.Convert2Sub<ShowerModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<ShowerModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_ThreeJoint:
                    {
                        var subModels = ModelFactory.Convert2Sub<SanTongModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<SanTongModel>(dataGrid);
                        break;
                    }

                case RevitType.RFT_Valve:
                    {
                        var subModels = ModelFactory.Convert2Sub<ValveModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<ValveModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_WaterBox:
                    {
                        var subModels = ModelFactory.Convert2Sub<WaterBoxModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<WaterBoxModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_WaterMeter:
                    {
                        var subModels = ModelFactory.Convert2Sub<WaterMeterModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<WaterMeterModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_WaterPool:
                    {
                        var subModels = ModelFactory.Convert2Sub<WaterPoolModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<WaterPoolModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_FireHydrant:
                    {
                        var subModels = ModelFactory.Convert2Sub<FireHydrantModel>(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<FireHydrantModel>(dataGrid);
                        break;
                    }
                case RevitType.RFT_Unknown:
                case RevitType.RFT_Others:
                default:
                    {
                        var subModels = ModelFactory.Convert2Others(models);
                        dataGrid.ItemsSource = subModels;
                        //HeaderConvertChs<OtherModel>(dataGrid);
                        break;
                    }
            }
        }

        private static void HeaderConvertChs<T>(DataGrid dataGrid) where T : ElementModel
        {
            Type type = typeof(T);
            var properties = type.GetProperties();
            foreach (var prop in properties)
            {
                var descAttr = prop.GetCustomAttribute<DescriptionAttribute>();
                if (descAttr == null) { continue; }

                var propName = prop.Name;
                var chsName = descAttr.Description;
                var column = dataGrid.Columns.Where(x => x.Header.ToString() == propName)?.FirstOrDefault();
                if (column == null) { continue; }

                column.Header = chsName;
            }
        }

        private static void InitDataGridColumns(DataGrid dataGrid, RevitType revitType)
        {
            Type type = RevitTypeExtense.GetElementModelType(revitType);
            PropertyInfo[] props = type.GetProperties();
            foreach (PropertyInfo prop in props)
            {
                var propName = prop.Name;
                var chsName = prop.GetCustomAttribute<DescriptionAttribute>()?.Description;
                if (string.IsNullOrEmpty(chsName)) { continue; }

                var column = new DataGridTextColumn();
                column.Header = chsName;
                dataGrid.Columns.Add(column);
            }
        }
    }
}