using EventBus;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;
using Uestc.Auto6.Dso.ComModel;
using Uestc.Auto6.Dso.Core;
using Uestc.Auto6.Dso.Core.Tools;
using Uni_Trend.MSO7000X.Common.Structs;
using Uni_Trend.MSO7000X.UserControls;

namespace Uestc.Auto6.Dso.U2
{
    public partial class DsoResultStrip : UserControl, IMeasView, ICymometerView, IVoltmeterView
    {
        private readonly List<UestcListPage> _MeasureInfo = new();

        private Boolean _FirstSetParentflag = true;

        private readonly Size _CymometerNormalSize;

        private readonly Size _VoltmeterNormalSize;

        private readonly Size _MeasureNormalSize;

        private readonly Int32 _MinWidth;

        public DsoResultStrip()
        {
            InitializeComponent();
            InitItemControl();

            _CymometerNormalSize = LpCymometerItem.Size;
            _VoltmeterNormalSize = LpVoltmeterItem.Size;
            _MeasureNormalSize = LpMeasureItem1.Size;
            _MinWidth = _MeasureNormalSize.Width * _MeasureInfo.Count + _CymometerNormalSize.Width + _VoltmeterNormalSize.Width;
        }

        protected new Boolean DesignMode
        {
            get
            {
                Boolean rtnflag = false;
#if DEBUG
                rtnflag = DesignTimeHelper.InDesignMode(this);
#endif
                return rtnflag;
            }
        }

        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.ExStyle |= 0x02000000;  // Turn on WS_EX_COMPOSITED
                return cp;
            }
        }

        private void InitItemControl()
        {
            _MeasureInfo.Add(LpMeasureItem1);
            _MeasureInfo.Add(LpMeasureItem2);
            _MeasureInfo.Add(LpMeasureItem3);
            _MeasureInfo.Add(LpMeasureItem4);
            _MeasureInfo.Add(LpMeasureItem5);
            _MeasureInfo.Add(LpMeasureItem6);
            _MeasureInfo.Add(LpMeasureItem7);
            _MeasureInfo.Add(LpMeasureItem8);
            _MeasureInfo.Add(LpMeasureItem9);
            _MeasureInfo.Add(LpMeasureItem10);

            for (Int32 i = 0; i < _MeasureInfo.Count; i++)
            {
                var measitem = _MeasureInfo[i];

                measitem.DashArray = null;
                //measitem.BackColor = Color.FromArgb(32, 32, 32);
                measitem.ValueForeColor = Color.FromArgb(192, 192, 192);
                measitem.AutoHide = false;
                //measitem.BorderThickness = 1;
                measitem.DisplayMember = "Key";
                measitem.ValueMember = "Value";
                measitem.DropBackOpacity = 85;
                measitem.Header = $"P{i + 1}";
                measitem.HeaderFont = AppStyleConfig.DefaultBoldFont;
                measitem.HeaderFont = AppStyleConfig.DefaultBoldFont;
                measitem.BackColor = AppStyleConfig.DefaultContextDarkBackColor;
                measitem.BorderColor = AppStyleConfig.DefaultContextDarkBackColor;
                measitem.HeaderBackColor = AppStyleConfig.DefaultContextBackColor;
                measitem.DisplayForeColor = AppStyleConfig.DefaultContextForeColor;
                measitem.HeaderForeColor = AppStyleConfig.DefaultContextForeColor;
                measitem.ValueForeColor = AppStyleConfig.DefaultTitleForeColor;

                measitem.MouseClick += LpMeasureItem_MouseClick;

                measitem.MouseDown += LpItemDragSource_MouseDown;
                measitem.MouseUp += LpItemDragSource_MouseUp;
                measitem.MouseMove += LpItemDragSource_MouseMove;
                measitem.GiveFeedback += LpItemDragSource_GiveFeedback;
                measitem.QueryContinueDrag += LpItemDragSource_QueryContinueDrag;
            }

            LpCymometerItem.HeaderFont = AppStyleConfig.DefaultBoldFont;
            LpCymometerItem.BackColor = AppStyleConfig.DefaultContextDarkBackColor;
            LpCymometerItem.BorderColor = AppStyleConfig.DefaultContextDarkBackColor;
            LpCymometerItem.HeaderBackColor = AppStyleConfig.DefaultContextBackColor;
            LpCymometerItem.DisplayForeColor = AppStyleConfig.DefaultContextForeColor;
            LpCymometerItem.HeaderForeColor = AppStyleConfig.DefaultContextForeColor;
            LpCymometerItem.ValueForeColor = AppStyleConfig.DefaultTitleForeColor;

            LpCymometerItem.MouseDown += LpItemDragSource_MouseDown;
            LpCymometerItem.MouseUp += LpItemDragSource_MouseUp;
            LpCymometerItem.MouseMove += LpItemDragSource_MouseMove;
            LpCymometerItem.GiveFeedback += LpItemDragSource_GiveFeedback;


            LpVoltmeterItem.HeaderFont = AppStyleConfig.DefaultBoldFont;
            LpVoltmeterItem.BackColor = AppStyleConfig.DefaultContextDarkBackColor;
            LpVoltmeterItem.BorderColor = AppStyleConfig.DefaultContextDarkBackColor;
            LpVoltmeterItem.HeaderBackColor = AppStyleConfig.DefaultContextBackColor;
            LpVoltmeterItem.DisplayForeColor = AppStyleConfig.DefaultContextForeColor;
            LpVoltmeterItem.HeaderForeColor = AppStyleConfig.DefaultContextForeColor;
            LpVoltmeterItem.ValueForeColor = AppStyleConfig.DefaultTitleForeColor;

            LpVoltmeterItem.MouseDown += LpItemDragSource_MouseDown;
            LpVoltmeterItem.MouseUp += LpItemDragSource_MouseUp;
            LpVoltmeterItem.MouseMove += LpItemDragSource_MouseMove;
            LpVoltmeterItem.GiveFeedback += LpItemDragSource_GiveFeedback;
        }

        public MeasPrsnt MeasPresenter
        {
            get;
            set;
        }

        IMeasPrsnt IView<IMeasPrsnt>.Presenter
        {
            get => MeasPresenter;
            set => MeasPresenter = (MeasPrsnt)value;
        }

        public CymometerPrsnt CymometerPresenter
        {
            get;
            set;
        }

        ICymometerPrsnt IView<ICymometerPrsnt>.Presenter
        {
            get => CymometerPresenter;
            set => CymometerPresenter = (CymometerPrsnt)value;
        }

        public VoltmeterPrsnt VoltmeterPresenter
        {
            get;
            set;
        }

        IBadge IView<IBadge>.Presenter
        {
            get => VoltmeterPresenter;
            set => VoltmeterPresenter = (VoltmeterPrsnt)value;
        }

        public void UpdateView(Object prsnt, String propertyName)
        {
            if (InvokeRequired)
            {
                BeginInvoke(new Action<Object, String>(Update), new[] { prsnt, propertyName });
            }
            else
            {
                Update(prsnt, propertyName);
            }
        }

        protected void Update(Object prsnt, String propertyName)
        {
            //switch (propertyName)
            //{
            //    case nameof(MeasPresenter.Active):
            //    case nameof(MeasPresenter.IsStatActive):
            //        UpdateView();
            //        break;
            //}
            if (propertyName.Contains("Active"))
            {
                UpdateView();
                SetParent();
            }
        }

        protected void UpdateView()
        {
            if (!DesignMode)
            {
                BtnAddMeasure.Visible = !MeasPresenter.IsAllActive() && MeasPresenter.Active;
                Boolean flag = false;
                for (Int32 i = 0; i < MeasPresenter.Length; i++)
                {
                    if (MeasPresenter.Active && MeasPresenter[i].Active)
                    {
                        _MeasureInfo[i].MeasItemName = MeasureApp.Default.Candidates[MeasPresenter[i].Name].Text;

                        _MeasureInfo[i].HeaderInfo = MeasPresenter[i].Source.ToString();
                        _MeasureInfo[i].HeaderInfoForeColor = MeasPresenter[i].DrawColor;
                        //_MeasureInfo[i].DisplayForeColor = MeasPresenter[i].SourceColor;
                        //_MeasureInfo[i].HeaderBackColor = MeasPresenter[i].SourceColor;
                        //_MeasureInfo[i].BorderColor = MeasPresenter[i].SourceColor;
                        _MeasureInfo[i].ShowIndicator = MeasPresenter.Indicator == i + 1;
                        //_MeasureInfo[i].ValueForeColor = Presenter[i].SourceColor;
                        //_MeasureInfo[i].HeaderForeColor = Color.Black;

                        #region Value

                        var (pfx, unit) = MeasPresenter.GetPfxUnitString(i);

                        var value = MeasPresenter.GetResult(i) ?? Double.NaN;
                        var max = MeasPresenter.GetStatMax(i) ?? Double.NaN;
                        var min = MeasPresenter.GetStatMin(i) ?? Double.NaN;
                        var ave = MeasPresenter.GetStatAverage(i) ?? Double.NaN;
                        var stddev = MeasPresenter.GetStatStddev(i) ?? Double.NaN;
                        var pop = (Double)MeasPresenter.GetStatCount(i);

                        List<KeyValuePair<String, String>> subitems = new();
                        if (Width <= _MinWidth)
                        {
                            subitems.Add(new("v", $"{new Quantity(value, pfx, unit)}"));
                            subitems.Add(new("M", $"{new Quantity(max, pfx, unit)}"));
                            subitems.Add(new("m", $"{new Quantity(min, pfx, unit)}"));
                            subitems.Add(new("μ", $"{new Quantity(ave, pfx, unit)}"));
                            subitems.Add(new("σ", $"{new Quantity(stddev, pfx, unit)}"));
                            subitems.Add(new("#", $"{new Quantity(pop, Prefix.Empty, QuantityUnit.Count.ToUnitString())}"));
                        }
                        else
                        {
                            subitems.Add(new(Properties.Resources.Statistic_VAL, $"{new Quantity(value, pfx, unit)}"));
                            subitems.Add(new(Properties.Resources.Statistic_MAX, $"{new Quantity(max, pfx, unit)}"));
                            subitems.Add(new(Properties.Resources.Statistic_MIN, $"{new Quantity(min, pfx, unit)}"));
                            subitems.Add(new(Properties.Resources.Statistic_AVG, $"{new Quantity(ave, pfx, unit)}"));
                            subitems.Add(new(Properties.Resources.Statistic_DEV, $"{new Quantity(stddev, pfx, unit)}"));
                            subitems.Add(new(Properties.Resources.Statistic_POP, $"{new Quantity(pop, Prefix.Empty, QuantityUnit.Count.ToUnitString())}"));
                        }

                        _MeasureInfo[i].DataSource = subitems;

                        #endregion
                        _MeasureInfo[i].DroppedDown = MeasPresenter.IsStatActive;

                        _MeasureInfo[i].Visible = true;
                        flag = true;
                    }
                    else
                    {
                        _MeasureInfo[i].Visible = false;
                    }

                    //if (MeasPresenter.Active && MeasPresenter.IsAnyActive())
                    //{
                    //    if (!BtnAddMeasure.Visible)
                    //    {
                    //        BtnAddMeasure.Visible = true;
                    //    }
                    //}
                    //else
                    //{
                    //    if (BtnAddMeasure.Visible)
                    //    {
                    //        BtnAddMeasure.Visible = false;
                    //    }
                    //}
                }

                if (CymometerPresenter.Active)
                {
                    List<String> frequencystring = FrequencyToString();
                    //LpCymometerItem.BackColor = Color.FromArgb(32, 32, 32);
                    LpCymometerItem.HeaderInfo = CymometerPresenter.Source.ToString();
                    LpCymometerItem.HeaderFont = AppStyleConfig.DefaultBoldFont;
                    LpCymometerItem.MeasItemName = frequencystring?.Count > 0 ? frequencystring[0] : "";
                    LpCymometerItem.DataSource = new List<KeyValuePair<String, String>>() { new(" ", frequencystring?.Count > 1 ? frequencystring[1] : "Hz") };
                    LpCymometerItem.HeaderInfoForeColor = CymometerPresenter.DrawColor;
                    LpCymometerItem.Visible = true;
                    flag = true;

                }
                else
                {
                    LpCymometerItem.Visible = false;
                }

                if (VoltmeterPresenter.Active)
                {
                    //LpVoltmeterItem.BackColor = Color.FromArgb(32, 32, 32);
                    LpVoltmeterItem.HeaderInfo = VoltmeterPresenter.Source.ToString();
                    LpVoltmeterItem.HeaderFont = AppStyleConfig.DefaultBoldFont;
                    LpVoltmeterItem.MeasItemName = VoltageToString();
                    LpVoltmeterItem.DataSource = new List<KeyValuePair<String, String>>() { new(" ", CouplingToString()) };
                    LpVoltmeterItem.HeaderInfoForeColor = CymometerPresenter.DrawColor;
                    LpVoltmeterItem.Visible = true;
                    flag = true;
                }
                else
                {
                    LpVoltmeterItem.Visible = false;
                }

                //Visible = flag;
                TmUpdate.Enabled = flag;
            }
        }

        public override void Refresh()
        {
            base.Refresh();
            UpdateView();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            Uni_Trend.MSO7000X.UserControls.Style.DefaultStyleManager.Instance.RegisterControlRecursion(this);
            //Disable UpdateView because MeasureApp is not initialized.
            //UpdateView();
            if (!DesignMode)
            {
                SizeChanged += DsoResultStrip_SizeChanged;
            }
        }

        private void DsoResultStrip_SizeChanged(Object sender, EventArgs args)
        {
            if (Width <= _MinWidth)
            {
                LpCymometerItem.Size = LpCymometerItem.MinimumSize;
                LpCymometerItem.ShowHeader = false;
                LpCymometerItem.BorderThickness = 0;

                LpVoltmeterItem.Size = LpVoltmeterItem.MinimumSize;
                LpVoltmeterItem.ShowHeader = false;
                LpVoltmeterItem.BorderThickness = 0;

                for (Int32 i = 0; i < _MeasureInfo.Count; i++)
                {
                    _MeasureInfo[i].Size = _MeasureInfo[i].MinimumSize;
                    _MeasureInfo[i].ShowHeader = false;
                    _MeasureInfo[i].BorderThickness = 0;
                    _MeasureInfo[i].Font = _MeasureInfo[i].DropedMeasNameItemFont = _MeasureInfo[i].DropedValueFont = new("Arial", 8);
                    _MeasureInfo[i].Percentage = 0.2f;
                }
            }
            else
            {
                LpCymometerItem.Size = _CymometerNormalSize;
                LpCymometerItem.ShowHeader = true;
                LpCymometerItem.BorderThickness = 1;

                LpVoltmeterItem.Size = _VoltmeterNormalSize;
                LpVoltmeterItem.ShowHeader = true;
                LpVoltmeterItem.BorderThickness = 1;

                for (Int32 i = 0; i < _MeasureInfo.Count; i++)
                {
                    _MeasureInfo[i].Size = _MeasureNormalSize;
                    _MeasureInfo[i].ShowHeader = true;
                    _MeasureInfo[i].BorderThickness = 1;
                    _MeasureInfo[i].Font = _MeasureInfo[i].DropedMeasNameItemFont = _MeasureInfo[i].DropedValueFont = new("Arial", 10.5F);
                    _MeasureInfo[i].Percentage = 0.45f;
                }
            }
        }

        private void TmUpdate_Tick(Object sender, EventArgs e)
        {
            UpdateView();
            if (_FirstSetParentflag)
            {
                SetParent();
                _FirstSetParentflag = false;
            }
        }

        private void SetParent()
        {
            for (int i = 0; i < _MeasureInfo.Count; i++)
            {
                if (MeasPresenter[i].Active && _MeasureInfo[i].DroppedDown)
                {
                    if (_MeasureInfo[i].DroppedDown)
                    {
                        _MeasureInfo[i].SetParent();
                    }
                }
            }
        }

        private void LpMeasureItem_MouseClick(Object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                return;
            }

            if (sender is UestcListPage measitempage)
            {
                Int32 pos = Int32.Parse(measitempage.Header[1..]) - 1;
                var point = new Point(0, 0);
                if (measitempage.DroppedDown)
                {
                    point = new Point(measitempage.Location.X + measitempage.Width / 2, (ParentForm as DsoForm).ActiveControl.Location.Y - measitempage.DropDownPageHeight + (ParentForm as DsoForm).ActiveControl.Height);
                }
                else
                {
                    point = new Point(measitempage.Location.X + measitempage.Width / 2, (ParentForm as DsoForm).ActiveControl.Location.Y);
                }
                point = (ParentForm as DsoForm).PointToScreen(point);
                (ParentForm as DsoForm)?.MakeOperateForm("MeasItemCfgForm", point, PopOrientation.Above, () =>
                {
                    var mif = new MeasItemCfgForm(pos)
                    {
                        Presenter = MeasPresenter,
                        Anchor = AnchorStyles.Bottom,
                    };
                    mif.Text = mif.Text + " " + measitempage.Header;
                    mif.Presenter.TryAddView(mif);
                    return mif;
                });
            }
        }

        private void LpCymometerItem_MouseClick(Object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                return;
            }

            (ParentForm as DsoForm)?.MakeOperateForm("Cymometer", GetPreferredLocation(sender as Control), PopOrientation.Above, () =>
            {
                var cf = new Cymometer.CymometerForm()
                {
                    Presenter = CymometerPresenter,
                    Anchor = AnchorStyles.Bottom,
                };
                cf.Presenter.TryAddView(cf);

                return cf;
            });
        }

        private void LpVoltmeterItem_MouseClick(Object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                return;
            }

            (ParentForm as DsoForm)?.MakeOperateForm("Voltmeter", GetPreferredLocation(sender as Control), PopOrientation.Above, () =>
            {
                var cf = new DVM.VoltmeterForm()
                {
                    Presenter = VoltmeterPresenter,
                    Anchor = AnchorStyles.Bottom,
                };
                cf.Presenter.TryAddView(cf);

                return cf;
            });
        }

        //private Point GetPreferredLocation(Int32 index)
        //{
        //    if (index < 0)
        //    {
        //        index = TlpBody.ColumnCount + index;
        //    }
        //    if (index < TlpBody.ColumnCount)
        //    {
        //        var c = TlpBody.GetControlFromPosition(index + 1, 0);
        //        if (c is not null)
        //        {
        //            return new(c.Left + c.Width / 2, Top);
        //        }
        //    }
        //    return new(Left, Top);
        //}

        private Point GetPreferredLocation(Control c)
        {
            if (c is not null)
            {
                return new(c.Left + c.Width / 2, Top);
            }

            return new(Left, Top);
        }


        private List<String> FrequencyToString()
        {
            return new Quantity(CymometerPresenter.GetFrequency(), Prefix.Empty, QuantityUnit.Hertz).ToString("##0.0000000", true, 9, true);
        }

        private String CouplingToString()
        {
            return VoltmeterPresenter.Mode switch
            {
                VoltmeterMode.DC => "DC",
                VoltmeterMode.ACrms => "ACrms",
                VoltmeterMode.DCACrms => "DC+AC",
                _ => "",
            };
        }

        private String VoltageToString()
        {
            return new Quantity(VoltmeterPresenter.GetVoltBymV(), Prefix.Milli, VoltmeterPresenter.Unit).ToString("##0.000", true, 6);
        }

        #region ToolTip
        //public void SetToolTip(ToolTip toolTip)
        //{
        //    toolTip.SetToolTip(SiCymometer, Properties.ToolTips.AboutCymometer);
        //    toolTip.SetToolTip(SiVoltmeter, Properties.ToolTips.AboutVoltmeter);
        //    foreach (var mi in _MeasureInfo)
        //    {
        //        toolTip.SetToolTip(mi, Properties.ToolTips.AboutMeasurement + " " + mi.Text);
        //    }
        //}

        #endregion

        #region DragDrop
        //!!!Sample code for DragDrop, here the DsoResultStrip's AllowDrop must be true.
        private UestcListPage _DeletedItem;

        private Rectangle _DragBox;

        private void LpItemDragSource_MouseDown(Object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {

                if (sender is UestcListPage)
                {
                    // Remember the point where the mouse down occurred. The DragSize indicates
                    // the size that the mouse can move before a drag event should be started.
                    Size ds = SystemInformation.DragSize;

                    // Create a rectangle using the DragSize, with the mouse position being
                    // at the center of the rectangle.
                    _DragBox = new Rectangle(new Point(e.X - (ds.Width / 2), e.Y - (ds.Height / 2)), ds);

                }
            }
        }

        private void LpItemDragSource_MouseUp(Object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                _DragBox = Rectangle.Empty;
            }
        }

        private void LpItemDragSource_MouseMove(Object sender, MouseEventArgs e)
        {
            if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
            {
                // If the mouse moves outside the rectangle, start the drag.
                if (_DragBox != Rectangle.Empty && !_DragBox.Contains(e.X, e.Y))
                {
                    // Proceed with the drag-and-drop, passing in the list item.
                    _DeletedItem = sender as UestcListPage;
                    if (_DeletedItem is not null)
                    {
                        DoDragDrop(_DeletedItem, DragDropEffects.Move);
                    }
                }
            }
        }

        private void LpItemDragSource_GiveFeedback(Object sender, GiveFeedbackEventArgs e)
        {
            // Sets the custom cursor based upon the effect.
            e.UseDefaultCursors = false;
            if ((e.Effect & DragDropEffects.Move) == DragDropEffects.Move)
            {
                Cursor.Current = Cursors.Hand;
            }
            else
            {
                Cursor.Current = Cursors.Default;
            }
        }

        private void LpItemDragSource_QueryContinueDrag(Object sender, QueryContinueDragEventArgs e)
        {
            // Cancel the drag if the mouse moves off the form.
            if (_DeletedItem is not null)
            {
                if (e.EscapePressed)
                {
                    e.Action = DragAction.Cancel;
                    _DeletedItem = null;
                }
            }
        }

        //private void DsoResultStrip_DragLeave(object sender, EventArgs e)
        //{
        //    if (_DeletedItem is not null)
        //    {
        //        if (_DeletedItem.Name.Contains("LpMeasure"))
        //        {
        //            Int32 idx = Int32.Parse(_DeletedItem.Header[1..]) - 1;
        //            MeasPresenter[idx].Active = false;
        //        }
        //        else if (_DeletedItem.Name.Contains("LpCymometer"))
        //        {
        //            CymometerPresenter.Active = false;
        //        }
        //        else if (_DeletedItem.Name.Contains("LpVoltmeter"))
        //        {
        //            VoltmeterPresenter.Active = false;
        //        }

        //        _DeletedItem = null;
        //    }
        //}
        #endregion

        //!!!Change focus to DsoResultStrip
        private void TlpBody_MouseDown(Object sender, MouseEventArgs e)
        {
            if (ActiveControl is null)
            {
                SelectNextControl(ActiveControl, true, true, true, true);
            }
        }

        private void BtnAddMeasure_Click(Object sender, EventArgs e)
        {
            var appenditem = MeasPresenter.SelectedItems.First(o => !o.Active);
            MeasSelectionForm msf = new(appenditem.Name, DsoPrsnt.FocusId, (n, s) =>
            {
                if (MeasPresenter.IsAllActive())
                {
                    WeakTip.Default.Write("Measure", MsgTipId.NoMoreMeasuerLabel);
                    return false;
                }

                var ai = MeasPresenter.SelectedItems.First(o => !o.Active);
                ai.Name = n;
                ai.Source = s;
                ai.Active = true;

                return true;
            })
            {
                StartPosition = FormStartPosition.CenterScreen,
            };

            msf.ShowDialogByEvent();
            //if (msf.DialogResult == DialogResult.Yes)
            //{
            //    appenditem.Name = msf.SelectedItemName;
            //    appenditem.Source = msf.Source;
            //    appenditem.Active = true;
            //}
        }
    }
}