using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Tango.FSE.Procedures.Contracts;
using Tango.FSE.Procedures.ViewModels;
using Tango.Logging;
using Tango.Scripting.Basic;
using Tango.Scripting.Core;
using Tango.Scripting.Editors;
using Tango.SharedUI.Helpers;

namespace Tango.FSE.Procedures.Views
{
    /// <summary>
    /// Interaction logic for ProcedureDesignerView.xaml
    /// </summary>
    public partial class ProcedureDesignerView : UserControl, IProcedureDesignerView
    {
        private ProcedureDesignerViewVM _vm;
        public event EventHandler<string> FileDropped;

        public ProcedureDesignerView()
        {
            InitializeComponent();
            this.Register<IProcedureDesignerView>();
            Loaded += (_, __) => _vm = DataContext as ProcedureDesignerViewVM;
        }

        private void OnScriptItemDoubleClick(object sender, MouseButtonEventArgs e)
        {
            _vm.OpenScript((sender as FrameworkElement).DataContext as Script);
        }

        private ScriptEditor GetCurrentEditor()
        {
            var editor = tabControl.FindVisualChildren<ScriptEditor>().FirstOrDefault(x => x.IsVisible);
            return editor;
        }

        private List<ScriptEditor> GetAllEditors()
        {
            return tabControl.FindVisualChildren<ScriptEditor>().ToList();
        }

        public void FormatCode()
        {
            GetCurrentEditor()?.FormatCode();
        }

        public void HighlightCode(int position, int length, int line)
        {
            GetCurrentEditor()?.Highlight(position, length, line);
        }

        public void InsertCode(string code)
        {
            GetCurrentEditor()?.InsertCode(code);
        }

        public void InvalidateHighlighting()
        {
            Dispatcher.BeginInvoke(new Action(() =>
            {
                foreach (var editor in tabControl.FindVisualChildren<ScriptEditor>())
                {
                    editor.InvalidateHighlighting(true);
                }
            }));
        }

        public void Find(string text)
        {
            GetCurrentEditor()?.Find(text);
        }

        public void ReplaceNext(string text, string replace)
        {
            GetCurrentEditor()?.ReplaceNext(text, replace);
            ColorizeKeyword(text);
        }

        public int ReplaceAll(string text, string replace)
        {
            var editor = GetCurrentEditor();

            if (editor != null)
            {
                int count = editor.ReplaceAll(text, replace);
                ColorizeKeyword(text);
                return count;
            }
            else
            {
                return 0;
            }
        }

        public void FocusCurrentEditor()
        {
            var editor = GetCurrentEditor();

            if (editor != null)
            {
                editor.Focus();
                Keyboard.Focus(editor);
            }
        }

        public void ColorizeKeyword(string text)
        {
            GetCurrentEditor()?.ColorizeByKeyword(text);
        }

        public void ResetColrization()
        {
            GetAllEditors().ForEach(x => x.ResetColorizationByKeyword());
        }

        private void OnDialogItemDoubleClick(object sender, MouseButtonEventArgs e)
        {
            _vm.EditProcedureDialog((sender as FrameworkElement).DataContext as ProcedureDialog);
        }

        public void HighlightError(int position, int length)
        {
            GetCurrentEditor()?.HighlighError(position, length);
        }

        public void ClearErrors()
        {
            GetAllEditors().ForEach(x => x.ClearErrors());
        }

        public void ScrollToLine(int lineNumber)
        {
            GetCurrentEditor().ScrollToLine(lineNumber);
        }

        public void HighlightRuntimeError(int lineNumber)
        {
            ScrollToLine(lineNumber);
            var editor = GetCurrentEditor();
            editor.HighlightErrorLine(lineNumber);
            UIHelper.DoEvents();
            Point? p = editor.GetLineVisualPosition(lineNumber);

            if (p != null)
            {
                Point point = p.Value;
                point = new Point(point.X, point.Y - editor.VerticalOffset);
                double height = editor.ActualHeight;

                if (point.Y > runTimeErrorDock.ActualHeight)
                {
                    DockPanel.SetDock(runTimeErrorLineGrid, Dock.Bottom);
                    runTimeErrorLineTransform.Angle = 0;
                    Canvas.SetTop(runTimeErrorDock, point.Y - runTimeErrorDock.ActualHeight);
                }
                else
                {
                    DockPanel.SetDock(runTimeErrorLineGrid, Dock.Top);
                    runTimeErrorLineTransform.Angle = 90;
                    Canvas.SetTop(runTimeErrorDock, point.Y);
                }

                Canvas.SetLeft(runTimeErrorDock, Math.Min(point.X, editor.ActualWidth - 110 - runTimeErrorDock.ActualWidth));

                runTimeErrorCanvas.Visibility = Visibility.Visible;
            }
        }

        public void CloseRunTimeError()
        {
            runTimeErrorCanvas.Visibility = Visibility.Hidden;
            GetCurrentEditor().ResetColorizationByKeyword();
        }

        public void HighlightDebugRequest(Object toDebug, int lineNumber)
        {
            ScrollToLine(lineNumber);
            var editor = GetCurrentEditor();
            editor.HighlightDebugLine(lineNumber);
            UIHelper.DoEvents();
            Point? p = editor.GetLineVisualPosition(lineNumber);

            if (p != null)
            {
                Point point = p.Value;

            }
        }

        public List<ScriptBreakPoint> GetBreakPoints()
        {
            List<ScriptBreakPoint> breakPoints = new List<ScriptBreakPoint>();

            foreach (var editor in GetAllEditors())
            {
                breakPoints.AddRange(editor.GetBreakPoints());
            }

            return breakPoints;
        }

        public void HighlightBreakPointRequest(int lineNumber, List<ScriptBreakPointSymbol> symbols)
        {
            UIHelper.DoEvents();
            ScrollToLine(lineNumber);
            var editor = GetCurrentEditor();
            editor.HighlightBreakPoint(lineNumber, symbols);
            UIHelper.DoEvents();
        }

        public void ResetBreakPointRequest()
        {
            GetCurrentEditor().ResetBreakPointLine();
            runTimeBreakPointCanvas.Visibility = Visibility.Hidden;
        }

        private void ScriptEditor_BreakPointSymbolPressed(object sender, BreakPointSymbolPressedEventArgs e)
        {
            try
            {
                var editor = GetCurrentEditor();
                var point = new Point(e.Position.X, e.Position.Y - editor.VerticalOffset);
                Canvas.SetTop(runTimeBreakPointDock, point.Y);
                Canvas.SetLeft(runTimeBreakPointDock, Math.Min(point.X, editor.ActualWidth - 110 - runTimeBreakPointDock.ActualWidth));


                try
                {
                    runTimeBreakPointTreeView.SetExpansion(false);
                }
                catch { }

                runTimeBreakPointTreeView.DataContext = DebugNode.CreateNode(e.BreakPointSymbol.Name, e.BreakPointSymbol.SymbolObject);
                runTimeBreakPointCanvas.Visibility = Visibility.Visible;
            }
            catch (Exception ex)
            {
                LogManager.Default.Log(ex, "Error initializing break point debug window.");
            }
        }

        private void RunTimeBreakPointCanvas_MouseUp(object sender, MouseButtonEventArgs e)
        {
            runTimeBreakPointCanvas.Visibility = Visibility.Hidden;
        }

        public string GetCaretWord()
        {
            return GetCurrentEditor()?.GetCaretWord();
        }

        private void OnFileDrop(object sender, DragEventArgs e)
        {
            try
            {
                string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);

                if (files != null && files.Length == 1)
                {
                    var file = files.First();
                    FileDropped?.Invoke(this, file);
                }
            }
            catch { }
        }
    }
}