using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TSA_V.Common;

namespace TSA_V.DeviceLibrary
{
    public class XYConvertManager
    {
        public static int BoundsWidth = 1920;
        public static int BoundsHeight = 1080;
        private static List<ConBaseInfo> conList = null;
        public static List<ConBaseInfo> ConList
        {
            get
            {
                if (conList == null)
                {
                    try
                    {
                        conList = JsonHelper.DeserializeJsonToObject<List<ConBaseInfo>>(Setting_NInit.Data_LastCalibrateInfo);
                    }
                    catch (Exception ex)
                    {
                        LogUtil.error("转换lastCalibrateBean出错：" + ex.ToString());
                    }
                }
                return conList;

            }
            set
            {
                conList = value;
                Setting_NInit.Data_LastCalibrateInfo = JsonHelper.SerializeObject(conList);
            }
        }

        public static void SaveData(BoardInfo board)
        {
            List<ConBaseInfo> data = new List<ConBaseInfo>() {
                new ConBaseInfo(new Point(0,0),board.calInfo.leftUpPoint),
                new ConBaseInfo(new Point(board.boardWidth,board.boardLength),board.calInfo.rightBottomPoint),
                };
        }



        public static SMTPointInfo CalPointNodePosition(SMTPointInfo smtPoint, List<SMTPointInfo> checkOKList)
        {
            try
            {
                if (smtPoint.CheckOK && Setting_NInit.Work_UseCheckOK)
                {
                    //校准点不再自动计算
                    return smtPoint;
                }
                if (checkOKList.Count < 2)
                {
                    return smtPoint;
                }
                double oldX = smtPoint.NodePositionX;
                double oldY = smtPoint.NodePositionY;
                //SMTPointInfo APoint = GetPoint(smtPoint, checkOKList);

                //SMTPointInfo BPoint = GetPoint(APoint, checkOKList);
                SMTPointInfo APoint = checkOKList[0];
                SMTPointInfo BPoint = checkOKList[1];



                //计算坐标    
                if (Math.Abs(smtPoint.PositionX - APoint.PositionX) < 0.01)
                {
                    smtPoint.NodePositionX = APoint.NodePositionX;
                }
                else
                {
                    smtPoint.NodePositionX = APoint.NodePositionX + (BPoint.NodePositionX - APoint.NodePositionX) * (smtPoint.PositionX - APoint.PositionX) / (BPoint.PositionX - APoint.PositionX);
                    if (double.IsNaN(smtPoint.NodePositionX) || double.IsInfinity(smtPoint.NodePositionX))
                    {
                        smtPoint.NodePositionX = APoint.NodePositionX;
                    }
                }
                if (Math.Abs(smtPoint.PositionY - APoint.PositionY) < 0.01)
                {
                    smtPoint.NodePositionY = APoint.NodePositionY;
                }
                else
                {
                    smtPoint.NodePositionY = APoint.NodePositionY + (BPoint.NodePositionY - APoint.NodePositionY) * (smtPoint.PositionY - APoint.PositionY) / (BPoint.PositionY - APoint.PositionY);
                    if (double.IsNaN(smtPoint.NodePositionY) || double.IsInfinity(smtPoint.NodePositionY))
                    {
                        smtPoint.NodePositionY = APoint.NodePositionY;
                    }
                }
                if (smtPoint.NodePositionX <= 0)
                {
                    smtPoint.NodePositionX = 1;
                }
                else if (smtPoint.NodePositionX > BoundsWidth)
                {
                    smtPoint.NodePositionX = BoundsWidth;
                }
                if (smtPoint.NodePositionY <= 0)
                {
                    smtPoint.NodePositionY = 1;
                }
                else if (smtPoint.NodePositionY > BoundsHeight)
                {
                    smtPoint.NodePositionY = BoundsHeight;
                }

                if (smtPoint.PointSizeX < 1 || smtPoint.PointSizeX > 255)
                {
                    smtPoint.PointSizeX = Setting_NInit.Device_DefaultPointSize;
                }
                if (smtPoint.PointSizeY < 1 || smtPoint.PointSizeY > 255)
                {
                    smtPoint.PointSizeY = Setting_NInit.Device_DefaultPointSize;
                }


                double xXishu = (BPoint.NodePositionX - APoint.NodePositionX) / (BPoint.PositionX - APoint.PositionX);
                double yXishu = (BPoint.NodePositionY - APoint.NodePositionY) / (BPoint.PositionY - APoint.PositionY);
                //计算点大小
                if (smtPoint.imgP?.uTime > smtPoint.pUTime)
                {
                    smtPoint.PointSizeX = (int)((BPoint.NodePositionX - APoint.NodePositionX) * smtPoint.imgP.SizeX / (BPoint.PositionX - APoint.PositionX));
                    smtPoint.PointSizeY = (int)((BPoint.NodePositionY - APoint.NodePositionY) * smtPoint.imgP.SizeY / (BPoint.PositionY - APoint.PositionY));
                    smtPoint.PenWidth = (int)((BPoint.NodePositionX - APoint.NodePositionX) * smtPoint.imgP.PWidth / (BPoint.PositionX - APoint.PositionX));

                }

                //smtPoint.PointSize = 4;
                //smtPoint.NodePositionX = BPoint.NodePositionX - (BPoint.NodePositionX - APoint.NodePositionX) * (BPoint.PositionX - smtPoint.PositionX) / (BPoint.PositionX - APoint.PositionX);
                //smtPoint.NodePositionY = BPoint.NodePositionY - (BPoint.NodePositionY - APoint.NodePositionY) * (BPoint.PositionY - smtPoint.PositionY) / (BPoint.PositionY - APoint.PositionY);
                LogUtil.info($" 【{smtPoint.PN}】图片坐标【{smtPoint.PositionX}，{smtPoint.PositionY}】旧坐标【{oldX}，{oldY}】新坐标【{smtPoint.NodePositionX}，{smtPoint.NodePositionY}】" +
                    $"点尺寸（{smtPoint.PointSizeX},{smtPoint.PointSizeY}）,画笔宽{smtPoint.PenWidth}");
                return smtPoint;

            }
            catch (Exception ex)
            {
                LogUtil.error(" 【" + smtPoint.PN + "】图片坐标【" + smtPoint.PositionX + "，" + smtPoint.PositionY + "】校准坐标出错：" + ex.ToString());

            }
            return smtPoint;
        }


        public static Point CalPCBAreaNodePosition(Point position, List<SMTPointInfo> checkOKList, int type)
        {
            Point nodePosition = new Point(0,0);
            try
            {
               
                if (checkOKList.Count < 2)
                {
                    return nodePosition;
                }  
                SMTPointInfo APoint = checkOKList[0];
                SMTPointInfo BPoint = checkOKList[1];
                 
                //计算坐标    
                if (Math.Abs(position.X - APoint.PositionX) < 0.01)
                {
                    nodePosition.X =(int) APoint.NodePositionX;
                }
                else
                {
                    nodePosition.X =(int)( APoint.NodePositionX + (BPoint.NodePositionX - APoint.NodePositionX) * (position.X - APoint.PositionX) / (BPoint.PositionX - APoint.PositionX));
                    if (double.IsNaN(nodePosition.X) || double.IsInfinity(nodePosition.X))
                    {
                        nodePosition.X =(int) APoint.NodePositionX;
                    }
                }
                if (Math.Abs(position.Y - APoint.PositionY) < 0.01)
                {
                    nodePosition.Y = (int)APoint.NodePositionY;
                }
                else
                {
                    nodePosition.Y =(int)( APoint.NodePositionY + (BPoint.NodePositionY - APoint.NodePositionY) * (position.Y - APoint.PositionY) / (BPoint.PositionY - APoint.PositionY));
                    if (double.IsNaN(nodePosition.Y) || double.IsInfinity(nodePosition.Y))
                    {
                        nodePosition.Y =(int) APoint.NodePositionY;
                    }
                }
                if (nodePosition.X <= 0)
                {
                    nodePosition.X = 1;
                }
                else if (nodePosition.X > BoundsWidth)
                {
                    nodePosition.X = BoundsWidth;
                }
                if (nodePosition.Y <= 0)
                {
                    nodePosition.Y = 1;
                }
                else if (nodePosition.Y > BoundsHeight)
                {
                    nodePosition.Y = BoundsHeight;
                }
                  
                //LogUtil.info($" 【{smtPoint.PN}】图片坐标【{smtPoint.PositionX}，{smtPoint.PositionY}】旧坐标【{oldX}，{oldY}】新坐标【{smtPoint.NodePositionX}，{smtPoint.NodePositionY}】" +
                //    $"点尺寸（{smtPoint.PointSizeX},{smtPoint.PointSizeY}）,画笔宽{smtPoint.PenWidth}");
                //return smtPoint;

            }
            catch (Exception ex)
            {
                LogUtil.error(" CalPointNodePosition 多PCB基准点计算错误【 图片坐标【" + position.X + "，" + position.Y + "】校准坐标出错：" + ex.ToString());

            }
            return nodePosition;
        }

        private SMTPointInfo GetPoint(SMTPointInfo smtPoint, List<SMTPointInfo> checkOKList)
        {
            SMTPointInfo p = null;
            double maxPingFang = 0;
            foreach (SMTPointInfo sm in checkOKList)
            {
                if (sm.pointNum.Equals(smtPoint.pointNum))
                {
                    continue;
                }
                double xjuli = sm.PositionX - smtPoint.PositionX;
                double yjuli = sm.PositionY - smtPoint.PositionY;
                double cping = xjuli * xjuli + yjuli * yjuli;
                if (cping > maxPingFang)
                {
                    p = sm;
                    maxPingFang = cping;
                    continue;
                }
            }
            if (p != null)
            {
                return p;
            }
            return null;
        }


        public static List<ProjectorPInfo> GetCopyProjectPointCR(BoardInfo board, SMTPointInfo sMTPoint = null)
        {
            List<SMTPointInfo> pointList = GetCopyPointCR(board, sMTPoint);
            List<ProjectorPInfo> projectorPInfoList = new List<ProjectorPInfo>();
            foreach (SMTPointInfo point in pointList)
            {
                ProjectorPInfo projectorPInfo = point.GetScreenShowPInfo();
                projectorPInfoList.Add(projectorPInfo);
            }
            return projectorPInfoList;
        }

        /// <summary>
        /// 多板拷贝点
        /// </summary>
        /// <param name="board"></param>
        /// <param name="sMTPoint"></param>
        /// <param name="targetRow"></param>
        /// <param name="targetCol"></param>
        /// <param name="targetRowValue"></param>
        /// <param name="targetColValue"></param>
        /// <returns></returns>
        public static List<List<Point>> GetCopyArea(BoardInfo board, int targetRow = 0, int targetCol = 0, int targetRowValue = 0, int targetColValue = 0)
        {
            List<List<Point>> result = new List<List<Point>>();
            if (board == null || board.calInfo == null || board.calInfo.leftUpPoint == null || board.calInfo.rightBottomPoint == null)
            {
                return result;
            }
            try
            {
                result.Add(new List<Point>() { board.calInfo.leftUpPoint, board.calInfo.rightBottomPoint });
                List<SMTPointInfo> checkOKList = board.getCalPoint();

                if (board == null || checkOKList == null || checkOKList.Count < 2 || board.PCBCount == 1)
                {
                    return result;
                }

                if (board.pcbRow <= 1 && board.pcbCol <= 1)
                {
                    return result;
                }

                int pcbRow = targetRow > 0 ? targetRow : board.pcbRow;
                int pcbCol = targetCol > 0 ? targetCol : board.pcbCol;
                int pcbColValue = targetColValue > 0 ? targetColValue : board.pcbColValue;
                int pcbRowValue = targetRowValue > 0 ? targetRowValue : board.pcbRowValue;
                for (int currR = 1; currR <= pcbRow; currR++)
                {
                    for (int currC = 1; currC <= pcbCol; currC++)
                    {
                        int index = (currR - 1) * pcbCol + currC;
                        if (index == 1) continue; // PCB1 为基准


                        // 默认按均匀间距计算
                        int dx = (currC - 1) * pcbColValue;
                        int dy = (currR - 1) * pcbRowValue;
                        // 若设置了某个PCB相对PCB1的偏移，则覆盖默认值
                        try
                        {
                            if (board.mPCbOffsetMap != null && board.mPCbOffsetMap.ContainsKey(index))
                            {
                                var pOffset = board.mPCbOffsetMap[index];
                                dx = pOffset.X;
                                dy = pOffset.Y;
                            }
                        }
                        catch { }


                        Point leftPoint = new Point(dx, dy);
                        Point rightPoint = new Point(dx + board.boardWidth, dy + board.boardLength);

                        if (checkOKList != null)
                        {
                            Point leftNodePoint = XYConvertManager.CalPCBAreaNodePosition(leftPoint, checkOKList, 1);
                            Point rightNodePoint = XYConvertManager.CalPCBAreaNodePosition(rightPoint, checkOKList, 2);

                            result.Add(new List<Point>() { leftNodePoint, rightNodePoint });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("获取" + board.boardName + "拷贝点出错：" + ex.ToString());
            }
            finally
            {

            }
            return result;
        }

        /// <summary>
        /// 多板拷贝点
        /// </summary>
        /// <param name="board"></param>
        /// <param name="sMTPoint"></param>
        /// <param name="targetRow"></param>
        /// <param name="targetCol"></param>
        /// <param name="targetRowValue"></param>
        /// <param name="targetColValue"></param>
        /// <returns></returns>
        public static List<SMTPointInfo> GetCopyPointCR(BoardInfo board, SMTPointInfo sMTPoint = null,int targetRow=0,int targetCol=0,int targetRowValue=0,int targetColValue=0)
        {
            List<SMTPointInfo> pointList = new List<SMTPointInfo>();
            try
            {

                List<SMTPointInfo> basePoints = new List<SMTPointInfo>();
                if (sMTPoint == null)
                {
                    if (board != null)
                    {

                        basePoints = new List<SMTPointInfo>(board.GetSmtList());
                    }
                    else
                    {

                        return pointList;
                    }
                }
                else
                {
                    basePoints.Add(sMTPoint);
                }
                List<SMTPointInfo> checkOKList = null;
                try
                {
                    if (board.calInfo != null)
                    {
                        checkOKList = board.getCalPoint();
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error("获取" + board.boardName + "校准点出错：" + ex.ToString());
                }
                if (board == null || checkOKList == null || checkOKList.Count < 2)
                {
                    return pointList;
                }
                pointList.AddRange(basePoints);
                int baseCount = basePoints.Count;
                string msg = "";

                if (board.pcbRow <= 1 && board.pcbCol <= 1)
                {
                    return pointList;
                }
                int pcbRow =targetRow>0?targetRow: board.pcbRow; 
                int pcbCol = targetCol > 0?targetCol: board.pcbCol; 
                int pcbColValue = targetColValue > 0?targetColValue: board.pcbColValue; 
                int pcbRowValue = targetRowValue > 0 ? targetRowValue: board.pcbRowValue;
          
                for (int currR = 1; currR <= pcbRow; currR++)
                {
                    for (int currC = 1; currC <= pcbCol; currC++)
                    {
                        int index = (currR - 1) * pcbCol + currC;
                        if (index == 1) continue; // PCB1 为基准

                        foreach (SMTPointInfo point in basePoints)
                        {
                            SMTPointInfo newPoint = new SMTPointInfo(point);
                            newPoint.pointNum = baseCount + point.pointNum;
                            // 默认按均匀间距计算
                            int dx = (currC - 1) * pcbColValue;
                            int dy = (currR - 1) * pcbRowValue;
                            // 若设置了某个PCB相对PCB1的偏移，则覆盖默认值
                            try
                            {
                                if (board.mPCbOffsetMap != null && board.mPCbOffsetMap.ContainsKey(index))
                                {
                                    var pOffset = board.mPCbOffsetMap[index];
                                    dx = pOffset.X;
                                    dy = pOffset.Y;
                                }
                            }
                            catch { }
                            newPoint.PositionX = newPoint.PositionX + dx;
                            newPoint.PositionY = newPoint.PositionY + dy;
                            newPoint.Group = index;
                            newPoint.TagNo = point.TagNo + "-" + index;
                            newPoint.PointSizeX = point.PointSizeX;
                            newPoint.CheckOK = false;

                            if (checkOKList != null)
                            {
                                try { newPoint = XYConvertManager.CalPointNodePosition(newPoint, checkOKList); } catch { }
                            }
                            msg += "\r\n" + point.pointName + "_" + point.PN + $"，更改组={index} ， X={newPoint.PositionX},Y={newPoint.PositionY}，投影X={newPoint.NodePositionX},投影Y={newPoint.NodePositionY}";
                            pointList.Add(newPoint);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error("获取" + board.boardName + "拷贝点出错：" + ex.ToString());
            }
            finally
            {

            }
            return pointList;
        }
    }

    public class ConBaseInfo
    {
        public ConBaseInfo()
        {

        }
        public ConBaseInfo(Point point1,Point point2)
        {
            this.IPoint = point1;
            this.Point = point2;
        }
        /// <summary>
        /// 板子实际坐标
        /// </summary>
        public Point IPoint = new Point();
        /// <summary>
        /// 投影对应坐标
        /// </summary>
        public Point Point = new Point(); 
    }
}