using Org.BouncyCastle.Ocsp;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using TSA_V.Common;
using TSA_V.DeviceLibrary;
using UserFromControl;

namespace TSA_V
{
    public partial class FrmProjectorScreen : Form
    {
        public static FrmProjectorScreen instance = new FrmProjectorScreen();
        public FrmProjectorScreen()
        {
            InitializeComponent();
            //ScreenIndex = ConfigAppSettings.GetIntValue(Setting_Init.ProjectorScreen_Index, 1);
            ScreenIndex = Setting_NInit.Device_ProjectorScreen_Index ;
        }
        public int ScreenIndex = 1;
        public int BoundsWidth = 1920;
        public int BoundsHeight = 1280;
        public int LastX = 0;
        public int LastY = 0;
        public int LastType = 1;
        public int LastSizeX = 2;
        public int LastSizeY = 2;
        public bool ISShow = false;
        //     private bool hasShow = false;
        private void FrmScreenTest_Load(object sender, EventArgs e)
        {
            this.Text = "投影_" + ScreenIndex;
            this.StartPosition = FormStartPosition.Manual;
            timer1.Start();
            if (panel1.BackgroundImage != null)
            {
                panel1.BackgroundImage = null;
            }
            if (lblAlarm.Visible)
            {
                lblAlarm.Visible = false;
            }
        }
        public bool CloseShowName = false;
        public bool ShowForm()
        {
            Screen[] sc = Screen.AllScreens;
            this.StartPosition = FormStartPosition.Manual;
            this.WindowState = FormWindowState.Maximized;
            if (sc.Count() > ScreenIndex)
            {
                Screen screen = sc[ScreenIndex];
                //foreach (Screen s in sc)
                //{
                //    if (!s.Primary)
                //    {
                //        screen = s;
                //        break;
                //    }
                //}

                string text = "名称：" + screen.DeviceName + "\r\n";
                text += "Width：" + screen.Bounds.Width + "\r\n";
                text += "Heigh：" + screen.Bounds.Height + "\r\n";
                text += "是否主显示器：" + screen.Primary.ToString() + "\r\n";
                //lblInfo.Text = text;

                BoundsWidth = screen.Bounds.Width;
                BoundsHeight = screen.Bounds.Height;

                TSAVBean.X_Max = BoundsWidth;
                TSAVBean.Y_Max = BoundsHeight;
                TSAVBean.X_Min = 1;
                TSAVBean.Y_Min = 1;
                //ProjectorControl.MaxX = (int)TSAVBean.X_Max;
                //ProjectorControl.MaxY = (int)TSAVBean.Y_Max;
                ISShow = true;

                this.Location = new Point(screen.Bounds.Left, screen.Bounds.Top);
                this.Show();
                LogUtil.info($"投影显示成功，屏幕索引={ ScreenIndex} , 位置X:{screen.Bounds.Left} ,Y:{screen.Bounds.Top} ,范围 X:{BoundsWidth},Y:{BoundsHeight}");
                return true;
            }
            else
            {
                LogUtil.info("投影显示失败：屏幕索引=" + ScreenIndex + " 未找到");
                return false;
            }

        }

        private void FrmScreenTest_Shown(object sender, EventArgs e)
        {
            ShowPoint(new ProjectorPInfo(BoundsWidth / 2, BoundsHeight / 2));
            DrawArea();
            panAoi.BackColor = Color.Black;
            panAoi.Visible = false;
        }
        public void DrawArea()
        {
            if (!ISShow)
            {
                return;
            }
            int startX = 0;
            int startY = 0;
            int Point_X_Length = 3;
            int Point_Y_Length = 3;
            int lineWidth = (BoundsWidth) / (Point_X_Length - 1);
            int lineHeight = (BoundsHeight) / (Point_Y_Length - 1);
            Graphics grfx = panel1.CreateGraphics();
            Color color = Color.White;
            grfx.SmoothingMode = SmoothingMode.HighQuality;

            //循环画线
            for (int i = 0; i <= Point_X_Length; i++)
            {
                float line = 2F;
                float picLocationX = startX + lineWidth * i;
                if (picLocationX >= BoundsWidth)
                {
                    picLocationX = BoundsWidth - 2;
                }
                else if (picLocationX == 0)
                {
                    picLocationX = 2;
                }
                grfx.DrawLine(new Pen(color, line), picLocationX, startY, picLocationX, BoundsHeight);

            }
            for (int i = 0; i <= Point_Y_Length; i++)
            {
                float line = 2F;
                float picLocationY = startY + lineHeight * i;
                if (picLocationY >= BoundsHeight)
                {
                    picLocationY = BoundsHeight - 1;
                }else if(picLocationY== 0)
                {
                    picLocationY = 2;
                }
                grfx.DrawLine(new Pen(color, line), startX, picLocationY, BoundsWidth, picLocationY);
            }
            grfx.Dispose();
        }
        public void DrawLine()
        {
            if (!ISShow)
            {
                return;
            }
            int startX = 0;
            int startY = 0;
            int Point_X_Length = 21;
            int Point_Y_Length = 21;

            int lineWidth = (BoundsWidth - startX * 2) / (Point_X_Length - 1);
            int lineHeight = (BoundsHeight - startY * 2) / (Point_Y_Length - 1);



            Graphics grfx = panel1.CreateGraphics();
            Color color = Color.White;
            grfx.SmoothingMode = SmoothingMode.HighQuality;

            //循环画线
            for (int i = 0; i <= Point_X_Length; i++)
            {
                float line = 0.2F;
                float picLocationX = startX + lineWidth * i;
                if (i.Equals(Point_X_Length / 2))
                {
                    line = 1;
                }
                else if (((i % 5).Equals(0)) && (i > 0) && (i < Point_X_Length))
                {
                    line = 0.5F;
                }

                grfx.DrawLine(new Pen(color, line), picLocationX, startY, picLocationX, BoundsHeight);

            }
            for (int i = 0; i <= Point_Y_Length; i++)
            {
                float line = 0.2F;
                float picLocationY = startY + lineHeight * i;
                if (i.Equals(Point_Y_Length / 2))
                {
                    line = 1;
                }
                else if (((i % 5).Equals(0)) && (i > 0) && (i < Point_Y_Length))
                {
                    line = 0.5F;
                }
                grfx.DrawLine(new Pen(color, line), startX, picLocationY, BoundsWidth, picLocationY);
            }
            grfx.Dispose();
        }

        private Color CurrColor = Color.White;

        public void ClearPoint()
        {
            try
            {
                if (!ISShow)
                {
                    return;
                }
                Graphics g = this.panel1.CreateGraphics();
                g.Clear(Color.Black);
                g.Dispose();//释放资源
            }
            catch (Exception ex)
            {
                LogUtil.error("ClearPoint 出错：" + ex.ToString());
            }

        }
        private void DrawPoint(Color color, Graphics g, int x, int y, int type = 0, int PolaritiesType=0,int angle=0, int sizeX = 2, int sizeY = 2, int lineLength = 2, string name = "")
        {
            if (sizeX < 2)
            {
                sizeX = 2;
            }
            if (sizeY < 2)
            {
                sizeY = 2;
            }
            LastX = x;
            LastY = y;
            LastSizeX = sizeX;
            LastSizeY = sizeY;
            LastType = type;
            Pen pen = new Pen(color, lineLength);

            System.Drawing.SolidBrush myBrush = new System.Drawing.SolidBrush(color);
            //点类型，1 = 点，2 = +，3 =|，4 = -，5 = 方形，6 = 圆圈
            if (type.Equals(PointType_Define.PlusSign_2))
            {
                g.DrawLine(pen, new Point(x - sizeX, y), new Point(x + sizeX, y));
                g.DrawLine(pen, new Point(x, y - sizeY), new Point(x, y + sizeY));
            }
            else if (type.Equals(PointType_Define.VerticalLine_3))
            {
                g.DrawLine(pen, new Point(x, y - sizeY), new Point(x, y + sizeY));
            }
            else if (type.Equals(PointType_Define.Line_4))
            {
                g.DrawLine(pen, new Point(x - sizeX, y), new Point(x + sizeX, y));
            }
            else if (type.Equals(PointType_Define.Rectangle_5))
            {
                g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else if (type.Equals(PointType_Define.Cycle_6))
            {
                g.DrawEllipse(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else if(type> PointType_Define.Cycle_6)
            {

                g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else
            {
                g.FillEllipse(myBrush, new Rectangle(x - sizeX / 2, y - sizeY / 2, sizeX, sizeY));//画实心椭圆          
            }
            

               if (PolaritiesType.Equals(PolaritiesType_Define.Plus_Up_1))
            {
                int plusSize = sizeX / 2;
                int pX = x;
                int pY = y - sizeY / 2 - lineLength - plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));

                //  g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_Down_2))
            {
                //    g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);

                int plusSize = sizeX / 2;
                int pX = x;
                int pY = y + sizeY / 2 + lineLength + plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_Left_3))
            {
                //   g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);

                int plusSize = sizeY / 2;
                int pX = x - sizeX / 2 - lineLength - plusSize;
                int pY = y;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_Right_4))
            {
                //  g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);

                int plusSize = sizeY / 2;
                int pX = x + sizeX / 2 + lineLength + plusSize;
                int pY = y;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_LUp_5))
            {
                int plusSize = sizeX / 2;
                int pX = x - plusSize;
                int pY = y - sizeY / 2 - lineLength - plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));

                // g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_RUp_6))
            {
                int plusSize = sizeX / 2;
                int pX = x + plusSize;
                int pY = y - sizeY / 2 - lineLength - plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));

                //  g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_LDown_7))
            {
                //   g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);

                int plusSize = sizeX / 2;
                int pX = x - plusSize;
                int pY = y + sizeY / 2 + lineLength + plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (PolaritiesType.Equals(PolaritiesType_Define.Plus_RDown_8))
            {
               // g.DrawRectangle(pen, x - sizeX / 2, y - sizeY / 2, sizeX, sizeY);

                int plusSize = sizeX / 2;
                int pX = x + plusSize;
                int pY = y + sizeY / 2 + lineLength + plusSize;
                g.DrawLine(pen, new Point(pX - plusSize, pY), new Point(pX + plusSize, pY));
                g.DrawLine(pen, new Point(pX, pY - plusSize), new Point(pX, pY + plusSize));
            }
            else if (angle > 0)
            {
                int pointWidth = sizeX;
                Point drawP = ProjectorPInfo.CalculatePoint(new Point(x, y), pointWidth, angle); 
                g.DrawLine(pen, new Point(drawP.X - pointWidth / 2, drawP.Y), new Point(drawP.X + pointWidth / 2, drawP.Y));
                g.DrawLine(pen, new Point(drawP.X, drawP.Y - pointWidth / 2), new Point(drawP.X, drawP.Y + pointWidth / 2));
            }
            if (!name.Equals(""))
            {
                int size = (sizeX + sizeY) / 2;
                size = 30;
                if (!CloseShowName)
                {
                    int textXWidth = size * StrLength (name)/ 3;
                    int yLength = size  ;
                    if (x - size < TSAVBean.X_Min)
                    {
                        x = x + size;
                    }
                    else if (x + 5 + textXWidth > TSAVBean.X_Max)
                    {
                        x =(int) TSAVBean.X_Max - textXWidth  -5;
                    } 
                      if (y + size + 2 + yLength > TSAVBean.Y_Max)
                    {
                        y = y -size- yLength - 5;
                    } 

                    Brush brush = new SolidBrush(color);
                    g.DrawString(name, new Font("Arial ", size/2, FontStyle.Regular), brush, x - size + 5, y + size + 2);
                }
            }
        }
        public static int StrLength(string inputString)
        {
            System.Text.ASCIIEncoding ascii = new System.Text.ASCIIEncoding();
            int tempLen = 0;
            byte[] s = ascii.GetBytes(inputString);
            for (int i = 0; i < s.Length; i++)
            {
                if ((int)s[i] == 63)
                    tempLen += 2;
                else
                    tempLen += 1;
            }
            return tempLen;
        }
        private Color getPointColor(int rgbColor = -1)
        {
            if (rgbColor >= 0xffffff)
            {
                rgbColor = Color.White.ToArgb();
            }
            return Color.FromArgb(rgbColor);
        }
        public void ShowPoint(DeviceLibrary.ProjectorPInfo p  )
        {
            if (!ISShow)
            {
                return;
            }
            Graphics g = panel1.CreateGraphics();
            Color pColor = Color.FromArgb(p.showColor);
            DrawPoint(pColor, g, (int)p.PX, (int)p.PY, p.PType,p.PolaritiesType,p.PolarityAngle, p.SizeX, p.SizeY, p.PenWidth, p.ShowText);
            g.Dispose();
        }
        public void ShowPoint(bool showName,int rgbColor, params SMTPointInfo[] points)
        {
            if (!ISShow)
            {
                return;
            }
            Color pColor = Color.FromArgb(rgbColor);
            ClearPoint();
            Graphics g = panel1.CreateGraphics();
            foreach (SMTPointInfo point in points)
            {
                int type = point.PointType;
                int x = (int)point.NodePositionX;
                int y = (int)point.NodePositionY;
                int sizex = point.PointSizeX;
                int sizey = point.PointSizeY;
                DrawPoint(pColor, g, x, y, type, point.PolaritiesType,point.PolarityAngle, sizex, sizey, point.PenWidth, "");

                if (showName)
                {
                    int size = (sizex + sizey) / 2;
                    if (!CloseShowName)
                    {
                        if (point.CheckOK && (points.Length > 1))
                        { 
                            g.DrawString(point.ShowText, new Font("Arial ", size, FontStyle.Regular), Brushes.Red, x - size / 2 + 5, y + size / 2 + 2);
                        }
                        else
                        {
                            Brush brush = new SolidBrush(pColor);
                            g.DrawString(point.ShowText, new Font("Arial ", size, FontStyle.Regular), brush, x - size / 2 + 5, y + size / 2 + 2);
                        }
                    }
                }
            }
            g.Dispose();
        }

        public void ShowBoardPoint(BoardInfo board, bool showName, int rgbColor, params SMTPointInfo[] points)
        {
            if (!ISShow)
            {
                return;
            }
            Color pColor = Color.FromArgb(rgbColor);
            ClearPoint();
            Graphics g = panel1.CreateGraphics();
            if (board != null && board.calInfo != null && board.calInfo.leftUpPoint != null && board.calInfo.rightBottomPoint != null)
            { 
                DrawBoardArea(g, board.calInfo.leftUpPoint, board.calInfo.rightBottomPoint);
            }
            foreach (SMTPointInfo point in points)
            {
                int type = point.PointType;
                int x = (int)point.NodePositionX;
                int y = (int)point.NodePositionY;
                int sizex = point.PointSizeX;
                int sizey = point.PointSizeY;
                DrawPoint(pColor, g, x, y, type, point.PolaritiesType,point.PolarityAngle, sizex, sizey, point.PenWidth, "");

                if (showName)
                {
                    int size = (sizex + sizey) / 2;
                    if (!CloseShowName)
                    {
                        if (point.CheckOK && (points.Length > 1))
                        {
                            g.DrawString(point.ShowText, new Font("Arial ", size, FontStyle.Regular), Brushes.Red, x - size / 2 + 5, y + size / 2 + 2);
                        }
                        else
                        {
                            Brush brush = new SolidBrush(pColor);
                            g.DrawString(point.ShowText, new Font("Arial ", size, FontStyle.Regular), brush, x - size / 2 + 5, y + size / 2 + 2);
                        }
                    }
                }
            }
            g.Dispose();
        }


        public void DrawBoardArea(Graphics g,Point point1,Point point2)
        {
            if (!ISShow)
            {
                return;
            }

            Color boardColor = Color.LightGray;

            int line = 1;
            g.DrawRectangle(new Pen(boardColor,line),new Rectangle( point1.X,point1.Y,(point2.X-point1.X),(point2.Y-point1.Y)));    
            //g.DrawLine(new Pen(boardColor, line), point1.X, point1.Y, point2.X,point1.Y);
            //g.DrawLine(new Pen(boardColor, line), point1.X, point1.Y, point1.X, point2.Y);
            //g.DrawLine(new Pen(boardColor, line), point1.X, point2.Y, point2.X, point2.Y);
            //g.DrawLine(new Pen(boardColor, line), point2.X, point2.Y, point1.X, point2.Y);
        }
        private void timer1_Tick(object sender, EventArgs e)
        {

            if (PTipSoundProcess.AOIopen)
            {
                panAoi.BackColor = Color.Black;
                panAoi.Visible = true;
            }
            else if (PTipSoundProcess.IsAlarm(out string msg) &&(! PTipSoundProcess.ViewScreen_Show)&&(!Setting_NInit.Device_SoftMode))
            {            
                panAoi.Visible = false;
                if (panel1.BackgroundImage != null)
                {
                    panel1.BackgroundImage = null;
                }
                else
                {
                    if (PTipSoundProcess.DisShowScreenAlarm)
                    {

                    }
                    else
                    {
                        panel1.BackgroundImage = ImageManager.imgAlarm;
                        panel1.BackgroundImageLayout = ImageLayout.Zoom;
                    }
                    lblAlarm.Text = msg;
                    lblAlarm.Visible = true;
                }
            }
            else
            {
                panAoi.Visible = false;
                if (panel1.BackgroundImage != null)
                {
                    panel1.BackgroundImage = null;
                }
                if (lblAlarm.Visible)
                {
                    lblAlarm.Visible = false;
                }
            }
        }
    }
    public class PolaritiesType_Define {
        public static int Plus_None = 0;

        /// <summary>
        ///    "1=正极限_上方",
        /// </summary>
        public static int Plus_Up_1 = 1;

        /// <summary>
        ///    "2=正极限_下方",
        /// </summary>
        public static int Plus_Down_2 = 2;

        /// <summary>
        /// "3=正极限_左方 ✚□",
        /// </summary>
        public static int Plus_Left_3 =3;

        /// <summary>
        ///"4=正极限_右方 □✚"
        /// </summary>
        public static int Plus_Right_4 = 4;


        /// <summary>
        ///    "5=正极限_左上方",
        /// </summary>
        public static int Plus_LUp_5 = 5;

        /// <summary>
        ///    "6=正极限_右上方",
        /// </summary>
        public static int Plus_RUp_6 = 6;

        /// <summary>
        /// "7=正极限_左下方",
        /// </summary>
        public static int Plus_LDown_7 = 7;

        /// <summary>
        ///"8=正极限_右下方"
        /// </summary>
        public static int Plus_RDown_8 = 8;
        /// <summary>
        /// 自定义角度
        /// </summary>
        public static int Plus_Custom = 9;
    }


    public class PointType_Define
    {

        public static int None = 0;
        /// <summary>
        ///  "1=●",
        /// </summary>
        public static int Point_1 = 1;
        /// <summary>
        ///   "2=✚",
        /// </summary>
        public static int PlusSign_2 = 2;
        /// <summary>
        ///  "3=┃",
        /// </summary>
        public static int VerticalLine_3 = 3;
        /// <summary>
        ///   "4=━━",
        /// </summary>
        public static int Line_4 = 4;
        /// <summary>
        ///   "5=□",
        /// </summary>
        public static int Rectangle_5 = 5;
        /// <summary>
        ///   "6=○"
        /// </summary>
        public static int Cycle_6 = 6;
        
           
        ///// <summary>
        /////    "7=正极限_上方",
        ///// </summary>
        //public static int Plus_Up_7 = 7;

        ///// <summary>
        /////    "8=正极限_下方",
        ///// </summary>
        //public static int Plus_Down_8 = 8;

        ///// <summary>
        ///// "9=正极限_左方 ✚□",
        ///// </summary>
        //public static int Plus_Left_9 = 9;

        ///// <summary>
        /////"10=正极限_右方 □✚"
        ///// </summary>
        //public static int Plus_Right_10 = 10;


        ///// <summary>
        /////    "11=正极限_左上方",
        ///// </summary>
        //public static int Plus_LUp_11 = 11;

        ///// <summary>
        /////    "12=正极限_右上方",
        ///// </summary>
        //public static int Plus_RUp_12 = 12;

        ///// <summary>
        ///// "13=正极限_左下方",
        ///// </summary>
        //public static int Plus_LDown_13 = 13;

        ///// <summary>
        /////"14=正极限_右下方"
        ///// </summary>
        //public static int Plus_RDown_14 = 14;
    }
}