using Editor.AppManager;
using Editor.CommandControl.ViewModel;
using Editor.CommandCore;
using Editor.CommandCustom;
using Editor.PluginInterface;
using Editor.WidzetPluginInterface;
using EditorCore;
using EGModeler.Controls;
using EGModeler.ViewModels;
using HmEG;
using HmEG.Controls;
using MahApps.Metro.Controls;
using System.Diagnostics;
using System;
using System.Globalization;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;


namespace EGModeler
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : MetroWindow
    {
        private ECommandManager ECommandManager { get => ECommandManager.GetCommandManager(0); }
        private SnapAssist? _snap;

        public MainWindow()
        {
            //테마 테스트
            //ThemeManager.Instance.SwitchTheme(ThemeType.ColorThemeBlack);
            InitializeComponent();
            MainWindowLoadingHelper.Instance.IsInitialized = true;
            this.DataContext = MainWindowViewModel.Instance;
            WidzetPlugin.AttachWidzet();
            HmEGAppManager.GetAppManager(0).SettingManager.PropertyChanged += PropertyChanged;
//#if !DEBUG //모델러 모드 강제 (배포 전 작업, 주석 해제 후 사용)
//            HmEGAppManager.GetAppManager(0).SettingManager.ModelerMode = ModelerMode.ModelingNViewing;
//#endif
            _snap = new SnapAssist(this);
            _snap.Attach();
        }

        private void PropertyChanged(object? sender, System.Reflection.PropertyInfo e)
        {
            if(e.Name.Equals("IsSidePanelVisible"))
            {
                var MainViewportGrid = this.FindChild<Grid>("MainViewportGrid");
                var isShow = HmEGAppManager.GetAppManager(0).SettingManager.IsSidePanelVisible;
                if(isShow)
                {
                    MainViewportGrid.ColumnDefinitions[1].Width = new GridLength(2);
                    MainViewportGrid.ColumnDefinitions[2].Width = new GridLength(MainViewportGrid.ColumnDefinitions[2].Width.Value, GridUnitType.Auto);
                    MainViewportGrid.ColumnDefinitions[2].MinWidth = 370;
                }
                else
                {
                    MainViewportGrid.ColumnDefinitions[1].Width = new GridLength(0);
                    MainViewportGrid.ColumnDefinitions[2].Width = new GridLength(0);
                    MainViewportGrid.ColumnDefinitions[2].MinWidth = 0;
                }
            }
//#if !DEBUG //모델러 모드 강제 (배포 전 작업, 주석 해제 후 사용)
//            if (e.Name.Equals("ModelerMode"))
//            {
//                var mode = HmEGAppManager.GetAppManager(0).SettingManager.ModelerMode;
//                if (mode != ModelerMode.ModelingNViewing)
//                {
//                    HmEGAppManager.GetAppManager(0).SettingManager.ModelerMode = ModelerMode.ModelingNViewing;
//                    HmEGAppManager.GetAppManager(0).UpdateSettingJson();
//                }
//            }
//#endif
        }

        private void titleBar_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            if(sender != null)
            {
                this.TitleBarHeight = (int)((System.Windows.Controls.UserControl)sender).ActualHeight;
            }
        }

        GridLength tmpHeight;

        GradientTransparencySettingPanel gradientTransparencySettingPanel = new GradientTransparencySettingPanel();
        private AdornerLayer _adornerLayer;
        private CustomAdorner _adorner;

        private void MainWindow_Loaded(object sender, System.Windows.RoutedEventArgs e)
        {
            _adornerLayer = AdornerLayer.GetAdornerLayer(settingOptionPanel);

            if (_adorner != null)
            {
                _adornerLayer.Remove(_adorner);
                _adorner = null;
                return;
            }

            ScrollContentPresenter scrollPresenter = new ScrollContentPresenter
            {
                Content = gradientTransparencySettingPanel
            };

            _adorner = new CustomAdorner(settingOptionPanel, scrollPresenter);
            _adornerLayer.Add(_adorner);

            var MainWindowContentGrid = this.FindChild<Grid>("MainWindowContentGrid");
            if (MainWindowContentGrid != null)
            {
                MainWindowContentGrid.RowDefinitions[2].Height = new GridLength(HmEGAppManager.GetAppManager(0).SettingManager.MainCommandPanelHeight);
                tmpHeight = MainWindowContentGrid.RowDefinitions[2].Height;
            }

            var screens = System.Windows.Forms.Screen.AllScreens;

            //뷰포트가 전부 로드되면 로딩창 닫는다.
            var viewports = this.FindChildren<EGViewport>();
            foreach(var  viewport in viewports)
            {
                viewCount++;
                viewport.OnRendered += Viewport_OnRendered;
            }

            if (HmEGAppManager.GetAppManager(0).SettingManager.IsSecondWindowOn)
            {
                var secondWindow = new SecondWindow();
                var primaryScreen = screens.FirstOrDefault(s => s.Primary);

                if (primaryScreen != null)
                {
                    var secondaryScreen = screens
                        .Where(s => s.Bounds.X > primaryScreen.Bounds.X)
                        .OrderBy(s => s.Bounds.X)
                        .FirstOrDefault();

                    Dispatcher.BeginInvoke(new Action(() =>
                    {
                        var dpi = GetDpiForScreen();
                        if (secondaryScreen != null)
                        {
                            secondWindow.Left = (secondaryScreen.WorkingArea.Left) / dpi;
                            secondWindow.Top = (secondaryScreen.WorkingArea.Top) / dpi;
                        }
                        else
                        {
                            secondWindow.Left = (primaryScreen.WorkingArea.Left) / dpi;
                            secondWindow.Top = (primaryScreen.WorkingArea.Top) / dpi;
                        }
                        secondWindow.Show();
                    }));
                }
                else
                {
                    secondWindow.Show();
                }

                var viewports2 = secondWindow.FindChildren<EGViewport>();
                if (HmEGAppManager.GetAppManager(0).SettingManager.IsSecondWindowOn)
                {
                    //세컨드윈도우 활성화를위한
                    foreach (var viewport in viewports2)
                    {
                        viewCount2++;
                        viewport.OnRendered += Viewport_OnRendered2;
                    }
                }
                else
                {
                    foreach (var viewport in viewports2)
                    {
                        HmEGAppManager.GetAppManager(0).UnRegisterViewport(viewport);
                    }
                }
            }

            totalViewCount = viewCount + viewCount2;
            MainWindowLoadingHelper.Instance.IsLoaded = true;
            Application.Current.MainWindow = this;
            IsSetLayout = true;
            CommandPanelViewModel.IncludedControls.Add(this);
        }

        private int totalViewCount = 0;
        //로드안된 뷰포트 수
        private int viewCount = 0;
        private async void Viewport_OnRendered(object? sender, EventArgs e)
        {
            var host = (DX11ImageSourceRenderHost)sender;
            ((EGViewport)host.Viewport).OnRendered -= Viewport_OnRendered;
            viewCount--;
            totalViewCount--;
            if (totalViewCount == 0)
            {
                if (App.LoadingWindow != null)
                {
                    if (App.LoadingWindow.Dispatcher.CheckAccess())
                        App.LoadingWindow.Close();
                    else
                        App.LoadingWindow.Dispatcher.Invoke(() => App.LoadingWindow.Close());
                }
                ResourceManager.Instance.GetMaterialImages();
            }
            if (viewCount == 0)
            {
                try
                {
                    await PluginLoader.LoadProjectPluginsAsync();
                }
                catch (Exception ex) { }

                //모든 뷰포트가 로드되면 로딩창 닫기전에 메인창 활성화 - 안하면 뒤로간다
                this.Activate();
                HmEGAppManager.GetAppManager(0).StartupCommandManager.ExecuteStartCommands();
                HmEG_DebugWidzetPlugin.AttachDebugTabs();
                Conference_DebugWidzetPlugin.AttachDebugTabs();
            }
        }

        //로드안된 두번째 윈도우 뷰포트 수
        private int viewCount2 = 0;
        private void Viewport_OnRendered2(object? sender, EventArgs e)
        {
            var host = (DX11ImageSourceRenderHost)sender;
            ((EGViewport)host.Viewport).OnRendered -= Viewport_OnRendered2;
            viewCount2--;
            totalViewCount--;
            //뷰포트가 로드되면 활성화
            if (viewCount2 == 0)
            {
                Window.GetWindow((EGViewport)host.Viewport).Activate();
            }
            if (totalViewCount == 0)
            {
                App.LoadingWindow.Dispatcher.Invoke(() =>
                {
                    App.LoadingWindow.Close();
                    //App.LoadingWindow.Dispatcher.InvokeShutdown();
                });
                ResourceManager.Instance.GetMaterialImages();
            }
        }


        private double GetDpiForScreen()
        {
            var source = PresentationSource.FromVisual(this);
            var matrix = source.CompositionTarget.TransformToDevice;

            double dpi = matrix.M11 * 96.0;

            return dpi / 96.0; 
        }

        private void ViewPortPanel_DragEnter(object sender, System.Windows.DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                e.Effects = DragDropEffects.Copy;
            }
            else
            {
                e.Effects = DragDropEffects.None;
            }
        }

        List<string> targetFiles;

        readonly Dictionary<string, string> extensions = new Dictionary<string, string>()
        {
            { "HANMAC Engineering Format", ".hmeg" },
            { "AutoCAD Drawing", ".dwg" },
            { "AutoCAD Drawing Exchange", ".dxf" },
            { "GRIMI Drawing File", ".grm" },
            { "Wavefront Object Format", ".obj" },
            //{ "Rhino 3D Model", ".3dm" },
            { "WPB File", ".wpb" },
            { "WPB_IFC File", ".wpb_ifc" },
            { "Industry Foundation Classes", ".ifc" },
            { "Triangulated Irregular Network", ".tins" },
            { "3D Studio", ".3ds" },
            { "Collada File", ".dae" },
            { "MotionBuilder", ".fbx" },
            { "glTF Binary File", ".glb" },
            { "glTF Text File", ".gltf" },
            { "XML File", ".xml" },
        };

        private void ViewPortPanel_Drop(object sender, System.Windows.DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);

                var allowedExtensions = extensions.Values.Select(ext => ext.ToLower()).ToList();

                var validFiles = files.Where(file =>
                {
                    string extension = System.IO.Path.GetExtension(file).ToLower();
                    return allowedExtensions.Contains(extension);
                }).ToArray();

                if (validFiles.Length > 1)
                {
                    if (!LoadingWindowHelperThread.Instance.IsOpen)
                        LoadingWindowHelperThread.Instance.Open();

                    var sb = new StringBuilder();
                    sb.Append("! ImportByPath ");
                    for (int i = 0; i < files.Count(); i++)
                    {
                        sb.Append("\"" + files[i] + "\"");
                        if (i != files.Count() - 1)
                            sb.Append("\u001F,");
                    }
                    ECommandManager.ExcuteCommand(sb.ToString());
                }
                else if(validFiles.Length == 1)
                {
                    string file = validFiles[0];
                    var owner = Application.Current.Windows.OfType<MainWindow>().FirstOrDefault();
                    MessageBoxResult result;
                    if (owner != null)
                    {
                        result = MessageBox.Show(
                            owner,
                            "파일을 Import 하시겠습니까?\n'아니오'를 선택하면 Open됩니다.",
                            "파일 처리 옵션",
                            MessageBoxButton.YesNoCancel,
                            MessageBoxImage.Question
                        );
                    }
                    else
                    {
                        result = MessageBox.Show(
                            "파일을 Import 하시겠습니까?\n'아니오'를 선택하면 Open됩니다.",
                            "파일 처리 옵션",
                            MessageBoxButton.YesNoCancel,
                            MessageBoxImage.Question
                        );
                    }

                    if (result == MessageBoxResult.Yes)
                    {
                        if (!LoadingWindowHelperThread.Instance.IsOpen)
                            LoadingWindowHelperThread.Instance.Open();

                        var sb = new StringBuilder();
                        sb.Append("! ImportByPath ");
                        foreach (var vfile in validFiles)
                        {
                            sb.Append("\"" + vfile + "\"");
                        }
                        ECommandManager.ExcuteCommand(sb.ToString());
                    }
                    else if (result == MessageBoxResult.No)
                    {
                        HmEGAppManager.GetAppManager(0).FileManager.Open(file);
                    }
                }
            }
        }

        bool IsSetLayout;
        private void CommandPanel_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            var MainWindowContentGrid = this.FindChild<Grid>("MainWindowContentGrid");
            if (MainWindowContentGrid != null & IsSetLayout)
            {
                HmEGAppManager.GetAppManager(0).SettingManager.MainCommandPanelHeight = MainWindowContentGrid.RowDefinitions[2].Height.Value;
                tmpHeight = MainWindowContentGrid.RowDefinitions[2].Height.Value < 100 ? tmpHeight : MainWindowContentGrid.RowDefinitions[2].Height;
                HmEGAppManager.GetAppManager(0).UpdateSettingJson();
                return;
            }
        }

        private void GridSplitter_MouseDoubleClick(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            var MainWindowContentGrid = this.FindChild<Grid>("MainWindowContentGrid");
            if (MainWindowContentGrid != null)
            {
                if(MainWindowContentGrid.RowDefinitions[2].Height.Value == 0)
                {
                    MainWindowContentGrid.RowDefinitions[2].Height = tmpHeight;
                }
                else
                {
                    MainWindowContentGrid.RowDefinitions[2].Height = new GridLength(0);
                }
            }
        }
    }

    public class BoolToParameterConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is bool boolValue)
            {
                if (boolValue)
                {
                    if (parameter != null)
                    {
                        return ConvertParameter(parameter, targetType);
                    }
                    return 0; 
                }
                else
                {
                    return 0;
                }
            }
            return 0; 
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException("ConvertBack is not implemented.");
        }

        private object ConvertParameter(object parameter, Type targetType)
        {
            if (parameter is string paramString)
            {
                if (targetType == typeof(double))
                    return double.TryParse(paramString, out double result) ? result : 0;
                if (targetType == typeof(int))
                    return int.TryParse(paramString, out int result) ? result : 0;
                if (targetType == typeof(GridLength))
                    return double.TryParse(paramString, out double result) ? new GridLength(result) : new GridLength(0);
            }
            return parameter;
        }
    }
}