using OTSCommon.Model;
using OTSIncAReportGraph.Class;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace OTSIncAReportGraph
{
    /// <summary>
    /// 包含DParticle类的field类,目前只用于绘制背景色，按理说应该有更多的作用，比如做多线程分式运算
    /// </summary>
    public class DisplayField : BaseObject
    {
        Guid  m_id;
        string m_tagid;
        string m_fieldid;
        bool m_IsDragging;
        Color m_backcolor;
        List<DisplayParticle> m_list_dparticle;

        List<DisplayParticle> m_list_Useparticle;
        PointF m_ots_point;  //按底层设计结构，底层返回的物理坐标位置及大小,OTS坐标大小
        RectangleF m_pix_rect; //与底层返回物理坐标及位置大小对应转换成，pixel像素分率下的坐标位置大小
        RectangleF m_show_rect;//最后换算到在显示器上显示的坐标位置大小
        RectangleF m_current_rect;//当前field在显示器上显示的坐标位置大小
        PointF m_dragingpoint;//鼠标拖动的位置
        //private string m_GBContent;
        private PointF m_OTSPointF;
        private bool m_IsSelect;
        private Color m_color;
        private GraphicsPath m_GPath;
        private Bitmap m_originalImage;
        const int INVALIDPARTICLE= -1;
        /// <summary>
        /// 构造函数
        /// </summary>
        public DisplayField(Field fld, int fldwidth, int fldheight,Point screenPos)
        {
            m_list_dparticle = new List<DisplayParticle>();
            m_list_Useparticle = new List<DisplayParticle>();
            m_id = System.Guid.NewGuid();
            Point thisfield_point = new Point() { X = fld.FieldPosX, Y = fld.FieldPosY };
           
            FieldID = fld.FieldID.ToString();
            Show_Rect = new Rectangle(screenPos, new Size(fldwidth, fldheight));
            Current_Rect = new Rectangle(screenPos, new Size(fldwidth, fldheight));
            OTSCoordinatePos = new PointF(thisfield_point.X, thisfield_point.Y);
            //先获取该Field中的所有Particle
            List<Particle> list_particle;
            list_particle = fld.ParticleList;

            //然后将取出的数据，转换成Bitmap对象
            m_originalImage = DrawFunction.ReadImageFile(fld.FieldImage);

            //再循环计算所有的Particle对象
            foreach (Particle particle in list_particle)
            {
                //分布图排列图无效颗粒不显示
                if (particle.TypeId == INVALIDPARTICLE)
                {
                    continue;
                }
                //创建DParticle颗粒
                DisplayParticle dp = new DisplayParticle(particle);

                List<Segment> list_seg;
                list_seg = particle.SegmentList;

                //创建颗粒分布图对应的类对象
                List<DisplaySegment> list_dsegment = new List<DisplaySegment>();


                //再循环取出里面所有的segment
                foreach (Segment seg in list_seg)
                {
                    #region 创建DSegment对象，并将STD分析出的化合物颜色保存到DSegment对象中
                    //对Particle里的Segment进行偏移的计算等,创建了DSegment的大小
                    DisplaySegment ds = new DisplaySegment();
                    ds.Rect = new Rectangle(seg.Start + screenPos.X,
                     
                       seg.Height + screenPos.Y,
                        seg.Length,
                        1);


                    ds.Color = dp.Color;//将线的颜色对应到颗粒的颜色
                    #endregion

                    #region //这里是在Field中，抠取出原BSE图像到DSegment中--------------------------------
                  
                    //合成图像完成，开始抠取像素-----------------------------------------------------------------
                    int f_length = seg.Length;
                    List<Color> ls_list_colors = new List<Color>();
                    for (int m = 0; m < f_length; m++)
                    {
                        //这里实现一下代码保护
                        int lsjs_x = seg.Start + m;
                     
                        int lsjs_y = seg.Height;
                   
                        ls_list_colors.Add(m_originalImage.GetPixel(lsjs_x,
                           lsjs_y));
                    }
                    //保存原BSE图中的颜色列表
                    ds.List_Colors = ls_list_colors;
                    #endregion //------------------------------------------------------------------------------

                    list_dsegment.Add(ds);

                }

          
                dp.SetPaintState(PaintState.NORMALPAINT);

                dp.DSegments = list_dsegment;

               
                dp.Rect = dp.GetRectFromDSegment();
                dp.GPath = dp.GetRegionFromDSegments();
                dp.SmallRect = dp.GetSmallRectangleFromRect();

               
                m_list_dparticle.Add(dp);
                if (dp.XRayId > -1)
                {
                    m_list_Useparticle.Add(dp);
                }

            }





        }

        public DisplayField(List<DisplayParticle> in_list_dparticle)
        {
            m_list_dparticle = in_list_dparticle;
        }



        public override Guid guid { get => m_id; set => m_id = value; }

        /// <summary>
        /// 记录与底层对应的TagID
        /// </summary>
        public string TagID
        {
            get { return m_tagid; }
            set { m_tagid = value; }
        }
        /// <summary>
        /// 是否被拖动标识
        /// </summary>


        public override bool IsDragging { get => m_IsDragging; set => m_IsDragging = value; }

        /// <summary>
        /// 被拖动到的位置坐标
        /// </summary>


        public override PointF DraggingPoint { get => m_dragingpoint; set => m_dragingpoint = value; }

        /// <summary>
        /// 与底层对应的ID,这里叫成FieldID
        /// </summary>
        public string FieldID
        {
            get { return m_fieldid; }
            set { m_fieldid = value; }
        }

        public override Color BackColor { get => m_backcolor; set => m_backcolor = value; }

        /// <summary>
        /// 包含的Particle列表
        /// </summary>
        public List<DisplayParticle> List_DParticle
        {
            get { return m_list_dparticle; }
            set { m_list_dparticle = value; }
        }
        public List<DisplayParticle> List_Useparticle
        {
            get { return m_list_Useparticle; }
            set { m_list_Useparticle = value; }
        }
        /// <summary>
        /// 该Field的OTS坐标及大小
        /// </summary>
        public PointF OTSCoordinatePos
        {
            get { return m_ots_point; }
            set { m_ots_point = value; }
        }

        /// <summary>
        /// 该Field物理坐标大小转换出，对应的像素坐标及大小
        /// </summary>
        public RectangleF Pix_Rect
        {
            get { return m_pix_rect; }
            set { m_pix_rect = value; }
        }

        /// <summary>
        /// 该Field最后在屏幕上显示的坐标及大小
        /// </summary>
        public RectangleF Show_Rect
        {
            get { return m_show_rect; }
            set { m_show_rect = value; }
        }

        /// <summary>
        /// Field当前在屏幕上显示的坐标及大小
        /// </summary>
        public RectangleF Current_Rect
        {
            get { return m_current_rect; }
            set { m_current_rect = value; }
        }

        public override RectangleF Rect { get => m_show_rect; set => m_show_rect = value; }
        public override PointF OTSPointF { get => m_OTSPointF; set => m_OTSPointF = value; }
        public override bool IsSelect { get => m_IsSelect; set => m_IsSelect = value; }
        public override Color Color { get => m_color; set => m_color = value; }
        public override GraphicsPath GPath { get => m_GPath; set => m_GPath = value; }
        public Bitmap OriginalImage { get => m_originalImage; set => m_originalImage = value; }

        public override void OnPaint(PaintEventArgs e)
        {

            //开始向下传递并进行绘制
            foreach (BaseObject item in m_list_dparticle)
            {
                DisplayParticle dp = (DisplayParticle)item;
                if (dp.IsDeleted==false)
                {
                    if (dp.GetPaintState() == PaintState.NORMALPAINT)
                    {
                        item.OnPaint(e);
                    }
                    //获取矩形的rectangle
                    dp.Rect = dp.GetRectFromDSegment();

                    //通过line获取路径边缘
                    dp.GPath = dp.GetRegionFromDSegments();

                    //重新计算小矩形边框
                    dp.SmallRect = dp.GetSmallRectangleFromRect();

                }
            }
        }
    }
}