using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Xml.Serialization;
using GeoSigma;
using GeoSigma.SigmaDrawerElement;
using GeoSigma.SigmaDrawerStyle;
using GeoSigma.SigmaDrawerStyle.Converter;
using SigmaDrawerStyle;
//using PropertyEditorColor = GeoSigma.SigmaDrawerStyle.PropertyEditorColor;

namespace SigmaDrawerElement
{
#pragma warning disable SA1402 // File may only contain a single type
#pragma warning disable SA1600 // Elements should be documented
#pragma warning disable SA1649 // File name should match first type name

    /// <summary>
    /// 散点数据道
    /// </summary>
    [XmlRoot("Pcg")]
    [TypeConverter(typeof(PropertySorter))]
    public class WellPointTrack : WellObjectXmlBase
    {
        //public WellPointTrack()
        //{
        //    wellPoleContext = new WellPoleContext();
        //}

        private const string PointTrackCategory = "\t\t\t\t\t散点道";
        private const string GridCategory = "\t\t\t\t网格";
        private const string FillCategory = "\t\t\t充填";
        private const string CurveStyleCategory = "\t\t曲线风格";
        private const string PointSymbolCategory = "\t点符号";

        // 曲线道
        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("标题"), PropertyOrder(0)]
        public string Title
        {
            get => CurveTrack.Title.Font.Text;
            set => CurveTrack.Title.Font.Text = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("曲线名称"), PropertyOrder(1)]
        public string CurveName
        {
            get => CurveTrack.Name;
            set => CurveTrack.Name = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("左值"), PropertyOrder(2)]
        public double LeftValue
        {
            get => CurveTrack.Left;
            set => CurveTrack.Left = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("右值"), PropertyOrder(3)]
        public double RightValue
        {
            get => CurveTrack.Right;
            set => CurveTrack.Right = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("标注格式"), PropertyOrder(4)]
        [TypeConverter(typeof(WellCurveTrackLabelFormatConverter))]
        public WellCurveTrackLabelFormat LabelFormat
        {
            get => DictionaryHelper.Reverse(WellCurveTrackLabelFormatConverter.Maps)[CurveTrack.GridStyle.Format];
            set => CurveTrack.GridStyle.Format = WellCurveTrackLabelFormatConverter.Maps[value];
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("对数"), PropertyOrder(5)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool IsLogarithmic
        {
            get => CurveTrack.Mode == "Log";
            set
            {
                // 这两个必须一定，不然显示会有问题
                CurveTrack.Mode = value ? "Log" : "Default";
                CurveTrack.CurveStyle.ShowStyle = CurveTrack.Mode;
            }
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("宽度"), PropertyOrder(6)]
        public double Width
        {
            get => CurveTrack.Width;
            set => CurveTrack.Width = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("道头字体"), PropertyOrder(7)]
        [Editor(typeof(PropertyEditorWellFontEx), typeof(UITypeEditor))]
        public WellFontEx HeaderFont
        {
            get => CurveTrack.Title.Font;
            set => CurveTrack.Title.Font = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("显示曲线横线"), PropertyOrder(9)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool ShowCurveLinear
        {
            get => CurveTrack.ShowLine;
            set => CurveTrack.ShowLine = value;
        }

        [XmlIgnore]
        [Category(PointTrackCategory)]
        [DisplayName("曲线显示样式"), PropertyOrder(10)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool CurveDisplayStyle
        {
            get => CurveTrack.CurveStyle.Visiable;
            set => CurveTrack.CurveStyle.Visiable = value;
        }

        // 网格
        [XmlIgnore]
        [Category(GridCategory)]
        [DisplayName("显示网格"), PropertyOrder(11)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool ShowGrid
        {
            get => CurveTrack.GridStyle.Visiable;
            set
            {
                // 在 pcg 中定义中，这两个是不同含义，
                // 但是在咱们的系统中它们表示含义相同，同步设置
                CurveTrack.GridStyle.Visiable = value;
                CurveTrack.GridStyle.IsDrawScale = value;
            }
        }

        [XmlIgnore]
        [Category(GridCategory)]
        [DisplayName("主刻度个数"), PropertyOrder(13)]
        public double MajorTicks
        {
            get => CurveTrack.GridStyle.MajorSpace;
            set => CurveTrack.GridStyle.MajorSpace = value;
        }

        [XmlIgnore]
        [Category(GridCategory)]
        [DisplayName("次刻度个数"), PropertyOrder(14)]
        public double MinorTicks
        {
            get => CurveTrack.GridStyle.MinorSpace;
            set => CurveTrack.GridStyle.MinorSpace = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填方式"), PropertyOrder(15)]
        [TypeConverter(typeof(WellCurveTrackFillTypeConverter))]
        public WellCurveTrackFillType FillMode
        {
            get => DictionaryHelper.Reverse(WellCurveTrackFillTypeConverter.XmlMaps)[CurveTrack.FillStyle.Mode];
            set => CurveTrack.FillStyle.Mode = WellCurveTrackFillTypeConverter.XmlMaps[value];
        }

        private static Dictionary<WellCurveTrackBrushType, string> fillModeMap = new Dictionary<WellCurveTrackBrushType, string>()
        {
            { WellCurveTrackBrushType.None, string.Empty },
            { WellCurveTrackBrushType.SingleColor, "Solid" },
            { WellCurveTrackBrushType.Picture, "Hatch" },
        };

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("画刷类型"), PropertyOrder(16)]
        [TypeConverter(typeof(WellCurveTrackBrushTypeConverter))]
        public WellCurveTrackBrushType BrushType
        {
            get => DictionaryHelper.Reverse(fillModeMap)[CurveTrack.FillMode];
            set => CurveTrack.FillMode = fillModeMap[value];
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填颜色"), PropertyOrder(17)]
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
        public Color FillColor
        {
            get => CurveTrack.FillStyle.BackColor;
            set => CurveTrack.FillStyle.BackColor = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填符号"), PropertyOrder(18)]
        [Editor(typeof(PropertyEditorFillSymbol), typeof(UITypeEditor))]
        public string FillSymbol
        {
            get => CurveTrack.FillStyle.Pattern;
            set => CurveTrack.FillStyle.Pattern = value;
        }

        //[XmlIgnore]
        //[Category(FillCategory)]
        //[DisplayName("充填曲线"), PropertyOrder(19)]
        //[TypeConverter(typeof(WellCurveTrackFillCurveConverter))]
        //public WellCurveTrackFillCurve FillCurve
        //{
        //    get => DictionaryHelper.Reverse(WellCurveTrackFillCurveConverter.Maps)[CurveTrack.FillStyle.SideTrack];
        //    set => CurveTrack.FillStyle.SideTrack = WellCurveTrackFillCurveConverter.Maps[value];
        //}

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("充填曲线"), PropertyOrder(19)]
        [TypeConverter(typeof(fillDiscreteCurveNamesConverter))]
        public string FillCurve
        {
            get => CurveTrack.FillStyle.SideTrack;
            set => CurveTrack.FillStyle.SideTrack = value;
        }

        [XmlIgnore]
        [Category(FillCategory)]
        [DisplayName("显示充填曲线"), PropertyOrder(20)]
        [TypeConverter(typeof(YesNoConverter))]
        public bool ShowFillCurve
        {
            get => CurveTrack.FillStyle.CurveVisiable;
            set => CurveTrack.FillStyle.CurveVisiable = value;
        }

        // 曲线风格
        [XmlIgnore]
        [Category(CurveStyleCategory)]
        [DisplayName("样式"), PropertyOrder(21)]
        [TypeConverter(typeof(WellCurveTrackStyleConverter))]
        public WellCurveTrackStyle Style
        {
            get => CurveTrack.CurveStyle.IsStep ? WellCurveTrackStyle.Step : WellCurveTrackStyle.Curve;
            set => CurveTrack.CurveStyle.IsStep = value == WellCurveTrackStyle.Step;
        }

        [XmlIgnore]
        [Category(CurveStyleCategory)]
        [DisplayName("曲线类型"), PropertyOrder(22)]
        public WellLineStyle CurveType
        {
            get => new WellLineStyle()
            {
                Color = CurveTrack.CurveStyle.Color,
                Width = CurveTrack.CurveStyle.Width,
                Style = CurveTrack.CurveStyle.Dash,
            };

            set
            {
                CurveTrack.CurveStyle.Color = value.Color;
                CurveTrack.CurveStyle.Width = value.Width;
                CurveTrack.CurveStyle.Dash = value.Style;
            }
        }

        // 点符号
        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("散点"), PropertyOrder(23)]
        [TypeConverter(typeof(WellCurveTrackCurveScatterConverter))]
        public WellCurveScatter Scatter
        {
            get => string.IsNullOrWhiteSpace(CurveTrack.SymbolStyle.Name) ? WellCurveScatter.None : WellCurveScatter.Scatter;
            set => CurveTrack.SymbolStyle.Name = WellCurveTrackCurveScatterConverter.Maps[value];
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号"), PropertyOrder(24)]
        [ListBoxEditor("PointType")]
        [Editor(typeof(PropertyEditorListBox), typeof(UITypeEditor))]
        public string Symbol
        {
            get => CurveTrack.SymbolStyle.Name;
            set => CurveTrack.SymbolStyle.Name = value;
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号边框颜色"), PropertyOrder(25)]
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
        public Color SymbolBorderColor
        {
            get => CurveTrack.SymbolStyle.ForeColor;
            set => CurveTrack.SymbolStyle.ForeColor = value;
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号填充颜色"), PropertyOrder(26)]
        [Editor(typeof(PropertyEditorColor), typeof(UITypeEditor))]
        public Color SymbolFillColor
        {
            get => CurveTrack.SymbolStyle.BackColor;
            set => CurveTrack.SymbolStyle.BackColor = value;
        }

        [XmlIgnore]
        [Category(PointSymbolCategory)]
        [DisplayName("符号大小"), PropertyOrder(27)]
        public double SymbolSize
        {
            get => CurveTrack.SymbolStyle.SizeWidth;
            set => CurveTrack.SymbolStyle.SizeWidth = value;
        }

        [Browsable(false)]
        [XmlAttribute("Version")]
        public string Version { get; set; }

        [Browsable(false)]
        [XmlElement("WellTrack")]
        public WellTrackWellTrack CurveTrack { get; set; }

        //[Browsable(false)]
        //[XmlIgnore]
        //public WellPoleContext wellPoleContext { get; set; }
    }

    public static class DataServiceFillDiscreteCurveNames
    {
        public static string[] GetAvailableOptions(Object param1)
        {
            string[] names = new string[0];
            if (param1 is WellPointTrack settings)
            {
                if (settings.wellPoleContext.geoWellPole.GetWellAllDiscreteNames(settings.wellPoleContext.wellObjHandle, out string[] NamesArr) == true)
                {
                    List<string> slist = new List<string>(NamesArr);
                    slist.Remove(settings.CurveName);

                    return slist.ToArray();
                }
            }

            return names;
        }
    }

    public class fillDiscreteCurveNamesConverter : GenericWellOptionsConverter<WellPointTrack>
    {
        public fillDiscreteCurveNamesConverter() : base(settings => DataServiceFillDiscreteCurveNames.GetAvailableOptions(settings))
        { }
    }

#pragma warning restore SA1649 // File name should match first type name
#pragma warning restore SA1600 // Elements should be documented
#pragma warning restore SA1402 // File may only contain a single type
}