using SA_LTT.Module;
using System;
using System.Collections.Generic;

namespace SA_LTT.Info.RecipeInfo
{
    public class Recipe
    {
        public string Name { get; set; }
        public float Radius { get; set; }
        public float DistanceFromCenterToPrimaryFlat { get; set; }
        public float EdgeRound { get; set; }

        public float BeamWidth { get; set; }
        public float BeamHeight { get; set; }

        public List<ProcessInfo> ProcessInfoList { get; set; }

        public Recipe()
        {
            Name = string.Empty;
            ProcessInfoList = new List<ProcessInfo>();
            ProcessInfoList.Clear();
            Radius = 75;
            DistanceFromCenterToPrimaryFlat = 30;
            EdgeRound = 0;

            BeamWidth = 0.1f;
            BeamHeight = 0.1f;
        }

        public void AddProcessInfo(ProcessInfo processInfo)
        {
            processInfo.Radius = Radius;
            processInfo.DistanceFromCenterToPrimaryFlat = DistanceFromCenterToPrimaryFlat;
            processInfo.EdgeRound = EdgeRound;
            processInfo.BeamWidth = BeamWidth;
            
            ProcessInfoList.Add(processInfo.Clone());
        }

        public Recipe Clone()
        {
            Recipe clone = new Recipe();

            clone.Name = this.Name;
            clone.Radius = this.Radius;
            clone.DistanceFromCenterToPrimaryFlat = this.DistanceFromCenterToPrimaryFlat;
            clone.EdgeRound = this.EdgeRound;

            clone.BeamWidth = this.BeamWidth;
            clone.BeamHeight = this.BeamHeight;

            clone.ProcessInfoList.AddRange(this.ProcessInfoList);

            return clone;
        }

        public static bool IsEquals(Recipe recipe1, Recipe recipe2)
        {
            bool check = true;

            if (recipe1 == null && recipe2 == null)
            {
                check = true;
            }
            else if ((recipe1 == null && recipe2 != null) || (recipe1 != null && recipe2 == null))
            {
                check = false;
            }
            else
            {
                check &= recipe1.Name == recipe2.Name;
                check &= recipe1.Radius == recipe2.Radius;
                check &= recipe1.DistanceFromCenterToPrimaryFlat == recipe2.DistanceFromCenterToPrimaryFlat;
                check &= recipe1.EdgeRound == recipe2.EdgeRound;

                check &= recipe1.BeamWidth == recipe2.BeamWidth;
                check &= recipe1.BeamHeight == recipe2.BeamHeight;
                
                if (recipe1.ProcessInfoList.Count == recipe2.ProcessInfoList.Count)
                {
                    for (int i = 0; i < recipe1.ProcessInfoList.Count; i++)
                    {
                        check &= ProcessInfo.IsEquals(recipe1.ProcessInfoList[i], recipe2.ProcessInfoList[i]);

                        if (check == false)
                            break;
                    }
                }
                else
                {
                    check = false;
                }
            }

            return check;
        }
    }

    public struct Coord
    {
        public ScanMode ScanMode { get; set; }
        public double X { get; set; }
        public double Y { get; set; }
        
        public Coord(ScanMode scanMode, double x, double y)
        {
            this.ScanMode = scanMode;
            this.X = x;
            this.Y = y;
        }
    }

    public class ProcessInfo
    {
        public double Radius { get; set; }
        public double DistanceFromCenterToPrimaryFlat { get; set; }
        public double EdgeRound { get; set; }

        public float StartX { get; set; }
        public float StartY { get; set; }

        public float Width { get; set; }
        public float Height { get; set; }

        public float ProcessStartX { get; set; }
        public float ProcessStartY { get; set; }
        public float ProcessEndX { get; set; }
        public float ProcessEndY { get; set; }

        public float BeamWidth { get; set; }
        public float BeamHeight { get; set; }
        
        public float BeamHeightOverlap { get; set; }

        public float BeamWidthOverlap { get; set; }

        public double ScannerProcessSpeed
        {
            get
            {
                return (BeamHeight - BeamHeightOverlap) * 1000;
            }
        }

        public double Energy { get; set; }

        public bool IsProcessEnable { get; set; }

        public double ProcessLength { get; set; }

        public double AccTime { get; set; }
        public List<Coord> ProcessList { get; set; }

        public ProcessInfo()
        {
            ProcessList = new List<Coord>();

            Radius = 75;
            DistanceFromCenterToPrimaryFlat = 70;
            EdgeRound = 0;

            StartX = 0;
            StartY = 0;
            Height = 0;
            Width = 0;

            BeamWidth = 0.1f;
            BeamHeight = 0.1f;
            AccTime = 100;
            SetProcessData();
        }

        public void SetRecipeData(Recipe recipe)
        {
            Radius = recipe.Radius;
            DistanceFromCenterToPrimaryFlat = recipe.DistanceFromCenterToPrimaryFlat;
            EdgeRound = recipe.EdgeRound;

            BeamWidth = recipe.BeamWidth;
            BeamHeight = recipe.BeamHeight;
        }

        //가공 생성, 언제 할 지 애매 ... 데이타 변경 때 마다 해야되려나 ...
        public void SetProcessData()
        {
            float beamHeight = BeamHeight - BeamHeightOverlap;
            beamHeight = float.Parse($"{beamHeight:F4}");

            if (Height % beamHeight != 0) //가공 높이가 beamHeight과 맞게 안떨어지면 딱 맞게 떨어지도록 변경.
            {
                int beamCount = (int)(Height / beamHeight);

                if (Height % beamHeight > beamHeight / 2)
                {
                    Height = (beamCount + 1) * beamHeight;
                }
                else
                {
                    Height = beamCount * beamHeight;
                }
            }

            if(IsProcessingAreaContainWafer())
            {
                if(GetProcessStartEndCoords())
                {
                    CreateProcessLines();
                }
            }
            else
            {
                ProcessStartX = 0;
                ProcessStartY = 0;
                ProcessEndX = 0;
                ProcessEndY = 0;
                ProcessList.Clear();
            }
        }

        //가공 범위가 웨이퍼 안에 있는지 확인.
        private bool IsProcessingAreaContainWafer()
        {
            bool isContainsEllipse = true;

            //웨이퍼 중심과 사각형 중심 사이의 거리.

            double left = StartX;
            double top = StartY;
            double right = left + Width;
            double bottom = top - Height;

            // 0, 0 <- 중심.
            if ((left <= 0 && 0 <= right) ||
                (bottom <= 0 && 0 <= top))
            {
                double processsRadius = Radius - EdgeRound;

                //사각형 반지름 만큼 확장
                double extendRectLeft = left - processsRadius;
                double extendRectTop = top + processsRadius;
                double extendRectRight = right + processsRadius;
                double extendRectBottom = bottom - processsRadius;

                //확장된 사각형 안에 중심이 오면 충돌
                if ((extendRectLeft < 0 && 0 < extendRectRight) &&
                    (extendRectBottom < 0 && 0 < extendRectTop))
                {
                    if (top < -DistanceFromCenterToPrimaryFlat)
                    {
                        isContainsEllipse = false;
                    }
                    else
                    {
                        isContainsEllipse = true;
                    }
                }
                else
                {
                    isContainsEllipse = false;
                }
            }
            else
            {
                //사각형의 꼭지점이 원 안에 오면 충돌
                if (IsCoordInWafer(left, top) ||
                    IsCoordInWafer(right, top) ||
                    IsCoordInWafer(left, bottom) ||
                    IsCoordInWafer(right, bottom))
                {
                    if (top < -(DistanceFromCenterToPrimaryFlat - EdgeRound))
                    {
                        isContainsEllipse = false;
                    }
                    else
                    {
                        isContainsEllipse = true;
                    }
                }
                else
                {
                    isContainsEllipse = false;
                }
            }

            IsProcessEnable = isContainsEllipse;

            return isContainsEllipse;
        }

        //가공 범위가 웨이퍼 안에 있으면 가공 시작 종료 위치 얻음.
        private bool GetProcessStartEndCoords()
        {
            if (IsProcessEnable == false) //가공 범위가 웨이퍼 안에 없으면 false 반환.
                return false;

            double processsRadius = Radius - EdgeRound;

            double startX, startY;
            double endX, endY;

            double left = StartX;
            double top = StartY;
            double right = left + Width;
            double bottom = top - Height;

            startX = 0;
            startY = 0;
            endX = 0;
            endY = 0;
            
            //=================== Start X, Y 구하기 =========================
            if (top >= 0)
            {
                if (top - Height > 0)
                {
                    startX = -Math.Sqrt(Math.Pow(processsRadius, 2) - Math.Pow(top - Height, 2));
                }
                else
                {
                    startX = -Math.Sqrt(Math.Pow(processsRadius, 2));
                }
            }
            else
            {
                startX = -Math.Sqrt(Math.Pow(processsRadius, 2) - Math.Pow(top, 2));
            }

            //Start X
            if (left < 0 && startX < left)
            {
                startX = left;
            }
            else if (left >= 0 && startX < left)
            {
                startX = left;
            }

            //Start Y
            if (top > processsRadius)
            {
                startY = processsRadius;
            }
            else
            {
                startY = top;
            }

            //==================================================

            //=================== End X, Y 구하기 =========================
            if (top >= 0)
            {
                if (top - Height > 0)
                {
                    //startY = top - Height;
                    endX = Math.Sqrt(Math.Pow(processsRadius, 2) - Math.Pow(top - Height, 2));
                }
                else
                {
                    endX = Math.Sqrt(Math.Pow(processsRadius, 2));
                }

                //startY = top;
            }
            else
            {
                endX = Math.Sqrt(Math.Pow(processsRadius, 2) - Math.Pow(top, 2));
            }

            //End X
            if (right <= processsRadius && right < endX)
            {
                endX = right;
            }

            //End Y
            if ( (top - Height) >= processsRadius)
            {
                endY = processsRadius;
            }
            else
            {
                endY = top - Height;
            }

            if (endY < -(DistanceFromCenterToPrimaryFlat - EdgeRound))
            {
                double beamHeightSize = BeamHeight - BeamHeightOverlap;

                double endHeight = top + (DistanceFromCenterToPrimaryFlat - EdgeRound);

                int beamCount = (int)(endHeight / beamHeightSize);

                if (endHeight % beamHeightSize > beamHeightSize / 2)
                {
                    beamCount++;
                }

                endY = top - (beamCount * beamHeightSize);
            }

            ProcessStartX = float.Parse($"{startX:F4}");
            ProcessStartY = float.Parse($"{startY:F4}");
            ProcessEndX = float.Parse($"{endX:F4}");
            ProcessEndY = float.Parse($"{endY:F4}");

            return true;
        }

        //좌표가 웨이퍼 안에 있는지 확인
        private bool IsCoordInWafer(double x, double y)
        {
            return Math.Pow(x, 2) + Math.Pow(y, 2) <= Math.Pow(Radius - EdgeRound, 2);
        }

        //X축을 기점으로 웨이퍼 접점 Y위치 반환.
        private double GetPointYOfContactOfEllips(double x, double y)
        {
            double position = 0;

            x = double.Parse($"{x:F4}");
            y = double.Parse($"{y:F4}");

            position = Math.Sqrt(Math.Pow(Radius - EdgeRound, 2) - Math.Pow(x, 2));
            
            position = y < 0 ? -position : position;

            position = double.Parse($"{position:F4}");
            return position;
        }

        //가공 좌표 List 생성
        private bool CreateProcessLines()
        {
            if (IsProcessEnable == false) //가공 범위가 웨이퍼 안에 없으면 false 반환.
                return false;

            int oddCheck = 0;
            ProcessLength = 0;

            double jumpY = 0;
            double markY = 0;

            float beamHeightSize = BeamHeight - BeamHeightOverlap;
            beamHeightSize = float.Parse($"{beamHeightSize:F4}");

            ProcessList.Clear(); // 기존 데이터 초기화
            bool _accLengthCheck = true;

            for (double i = ProcessStartX; i <= ProcessEndX; i += (BeamWidth - BeamWidthOverlap)) // X축 방향 탐색
            {
                //가공 시작 기준
                if (ProcessEndY >= 0) // 가공 End 가 0보다 위일 때, End위치 기준으로.
                {
                    if (oddCheck % 2 == 0) // 짝수 (left top, start 위치에서 시작)
                    {
                        //Jump
                        if (IsCoordInWafer(i, ProcessEndY + Height))
                        {
                            jumpY = ProcessEndY + Height;
                        }
                        else
                        {
                            jumpY = GetPointYOfContactOfEllips(i, ProcessEndY + Height);
                            
                            if((jumpY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                jumpY = ProcessEndY + (beamHeightSize * Math.Floor((jumpY - ProcessEndY) / beamHeightSize));
                            }
                            else
                            {
                                jumpY = ProcessEndY + (beamHeightSize * Math.Ceiling((jumpY - ProcessEndY) / beamHeightSize));
                            }
                        }

                        //Mark
                        if (IsCoordInWafer(i, ProcessEndY))
                        {
                            markY = ProcessEndY;
                        }
                        else
                        {
                            markY = GetPointYOfContactOfEllips(i, ProcessEndY);

                            if ((markY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                markY = ProcessEndY + (beamHeightSize * Math.Floor((markY - ProcessEndY) / beamHeightSize));
                            }
                            else
                            {
                                markY = ProcessEndY + (beamHeightSize * Math.Ceiling((markY - ProcessEndY) / beamHeightSize));
                            }
                        }
                    }
                    else // 홀수 (right bottom, 위치에서 시작)
                    {
                        //Jump
                        if (IsCoordInWafer(i, ProcessEndY))
                        {
                            jumpY = ProcessEndY;
                        }
                        else
                        {
                            jumpY = GetPointYOfContactOfEllips(i, ProcessEndY);

                            if ((jumpY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                jumpY = ProcessEndY + (beamHeightSize * Math.Floor((jumpY - ProcessEndY) / beamHeightSize));
                            }
                            else
                            {
                                jumpY = ProcessEndY + (beamHeightSize * Math.Ceiling((jumpY - ProcessEndY) / beamHeightSize));
                            }
                        }

                        //Mark
                        if (IsCoordInWafer(i, ProcessEndY + Height))
                        {
                            markY = ProcessEndY + Height;
                        }
                        else
                        {
                            markY = GetPointYOfContactOfEllips(i, ProcessEndY + Height);

                            if ((markY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                markY = ProcessEndY + (beamHeightSize * Math.Floor((markY - ProcessEndY) / beamHeightSize));
                            }
                            else
                            {
                                markY = ProcessEndY + (beamHeightSize * Math.Ceiling((markY - ProcessEndY) / beamHeightSize));
                            }
                        }
                    }

                    if(_accLengthCheck && jumpY >= ProcessStartY)
                    {
                        _accLengthCheck = false;
                        AccTime = ProcessLength / ScannerProcessSpeed;
                    }
                }
                else // 가공 End가 0보다 밑일 때
                {
                    if (oddCheck % 2 == 0) // 짝수 (left top, start 위치에서 시작)
                    {
                        //Jump
                        if (IsCoordInWafer(i, ProcessStartY))
                        {
                            jumpY = ProcessStartY;
                        }
                        else
                        {
                            jumpY = GetPointYOfContactOfEllips(i, ProcessStartY);

                            if ((jumpY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                jumpY = ProcessStartY - (beamHeightSize * Math.Floor((ProcessStartY - jumpY) / beamHeightSize));
                            }
                            else
                            {
                                jumpY = ProcessStartY - (beamHeightSize * Math.Ceiling((ProcessStartY - jumpY) / beamHeightSize));
                            }
                        }

                        //Mark
                        if (IsCoordInWafer(i, ProcessStartY - Height))
                        {
                            markY = ProcessStartY - Height;
                        }
                        else
                        {
                            markY = GetPointYOfContactOfEllips(i, ProcessStartY - Height);
                            
                            if ((jumpY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                markY = ProcessStartY - (beamHeightSize * Math.Floor((ProcessStartY - markY) / beamHeightSize));
                            }
                            else
                            {
                                markY = ProcessStartY - (beamHeightSize * Math.Ceiling((ProcessStartY - markY) / beamHeightSize));
                            }
                        }
                    }
                    else // 홀수 (right bottom, 위치에서 시작)
                    {
                        //Jump
                        if (IsCoordInWafer(i, ProcessStartY - Height))
                        {
                            jumpY = ProcessStartY - Height;
                        }
                        else
                        {
                            jumpY = GetPointYOfContactOfEllips(i, ProcessStartY - Height);

                            if ((jumpY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                jumpY = ProcessStartY - (beamHeightSize * Math.Floor((ProcessStartY - jumpY) / beamHeightSize));
                            }
                            else
                            {
                                jumpY = ProcessStartY - (beamHeightSize * Math.Ceiling((ProcessStartY - jumpY) / beamHeightSize));
                            }
                        }

                        //Mark
                        if (IsCoordInWafer(i, ProcessStartY))
                        {
                            markY = ProcessStartY;
                        }
                        else
                        {
                            markY = GetPointYOfContactOfEllips(i, ProcessStartY);

                            if ((markY % beamHeightSize) >= (beamHeightSize / 2))
                            {
                                markY = ProcessStartY - (beamHeightSize * Math.Floor((ProcessStartY - markY) / beamHeightSize));
                            }
                            else
                            {
                                markY = ProcessStartY - (beamHeightSize * Math.Ceiling((ProcessStartY - markY) / beamHeightSize));
                            }
                        }
                    }

                    if (_accLengthCheck && jumpY <= ProcessEndY)
                    {
                        _accLengthCheck = false;
                        AccTime = ProcessLength / ScannerProcessSpeed;
                    }
                }

                if (jumpY < ProcessEndY)
                {
                    jumpY = ProcessEndY;
                }

                if (markY < ProcessEndY)
                {
                    markY = ProcessEndY;
                }

                jumpY = double.Parse($"{jumpY:F4}");
                markY = double.Parse($"{markY:F4}");
                i = double.Parse($"{i:F4}");

                ProcessList.Add(new Coord(ScanMode.JUMP, i, jumpY));
                ProcessList.Add(new Coord(ScanMode.MARK, i, markY));

                ProcessLength += Math.Abs(markY - jumpY);
                //ProcessLength += Math.Abs(ProcessStartY - ProcessEndY);
                ProcessLength += 0.1 + 0.1; // JumpDelay + MarkDelay;
                ProcessLength += beamHeightSize;

                oddCheck++;
            }

            // Process y - y = 3950.64
            // mark y -y = 3723.49
            ProcessLength = double.Parse($"{ProcessLength:F3}");
            return true;
        }

        public ProcessInfo Clone()
        {
            ProcessInfo processInfo = new ProcessInfo();

            processInfo.Radius = Radius;
            processInfo.DistanceFromCenterToPrimaryFlat = DistanceFromCenterToPrimaryFlat;
            processInfo.EdgeRound = EdgeRound;

            processInfo.StartX = StartX;
            processInfo.StartY = StartY;
            processInfo.Height = Height;
            processInfo.Width = Width;

            processInfo.ProcessStartX = ProcessStartX;
            processInfo.ProcessStartY = ProcessStartY;
            processInfo.ProcessEndX = ProcessEndX;
            processInfo.ProcessEndY = ProcessEndY;

            processInfo.BeamWidth = BeamWidth;
            processInfo.BeamHeight = BeamHeight;

            processInfo.BeamHeightOverlap = BeamHeightOverlap;
            processInfo.BeamWidthOverlap = BeamWidthOverlap;
            processInfo.Energy = Energy;

            processInfo.IsProcessEnable = IsProcessEnable;

            foreach(Coord coord in ProcessList)
            {
                Coord copy = new Coord(coord.ScanMode, coord.X, coord.Y);

                processInfo.ProcessList.Add(copy);
            }

            return processInfo;
        }

        public static bool IsEquals(ProcessInfo info1, ProcessInfo info2)
        {
            bool check = true;

            if (info1 == null && info2 == null)
            {
                check = true;
            }
            else if ((info1 == null && info2 != null) || (info1 != null && info2 == null))
            {
                check = false;
            }
            else
            {
                check &= info1.Radius == info2.Radius;
                check &= info1.DistanceFromCenterToPrimaryFlat == info2.DistanceFromCenterToPrimaryFlat;

                check &= info1.StartX == info2.StartX;
                check &= info1.StartY == info2.StartY;
                check &= info1.Height == info2.Height;
                check &= info1.Width == info2.Width;

                check &= info1.ProcessStartX == info2.ProcessStartX;
                check &= info1.ProcessStartY == info2.ProcessStartY;
                check &= info1.ProcessEndX == info2.ProcessEndX;
                check &= info1.ProcessEndY == info2.ProcessEndY;

                check &= info1.BeamWidth == info2.BeamWidth;

                check &= info1.BeamHeightOverlap == info2.BeamHeightOverlap;
                check &= info1.BeamWidthOverlap == info2.BeamWidthOverlap;
                
                check &= info1.IsProcessEnable == info2.IsProcessEnable;

                check &= info1.Energy == info2.Energy;

                if (info1.ProcessList.Count == info2.ProcessList.Count)
                {
                    for (int i = 0; i < info1.ProcessList.Count; i++)
                    {
                        check &= info1.ProcessList[i].ScanMode == info2.ProcessList[i].ScanMode;
                        check &= info1.ProcessList[i].X == info2.ProcessList[i].X;
                        check &= info1.ProcessList[i].Y == info2.ProcessList[i].Y;

                        if (check == false)
                            break;
                    }
                }
                else
                {
                    check = false;
                }
            }
            return check;
        }
    }
}