/*
  * Copyright (c) 2025 LG Electronics Inc.
   * SPDX-License-Identifier: LicenseRef-LGE-Proprietary
   */
using Aurora.Api;
using CogCommon;
using VisionCommon;
using Hermes;
using Cognex.VisionPro;
using Cognex.VisionPro.Caliper;
using System;
using System.IO;
using System.Collections.Generic;
using System.Drawing;

namespace CogPattern {
    public class LineWidthRunParam : IRunParam, ICloneable {
        public int PatternId1 { get; set; } = -1;
        public int PatternId2 { get; set; } = -1;

        public object Clone() {
            return new LineWidthRunParam() {
                PatternId1 = PatternId1,
                PatternId2 = PatternId2
            };
        }
    }

    public class LineWidth : PatternBase, IPatternFinder, IPatternBlock, IDisposable {
        public string FILE_EXT_PATTERN { get; set; } = ".json";
        private PatternBlockParamExt _paramExt = null;

        private Logger _logger;
        private PatternInfo _patternInfo;

        public LineWidth(PatternInfo patternInfo) {
            _patternInfo = patternInfo;
            _logger = new Logger(
                $"LineWidth_{patternInfo.GetPatternIndex()}");
            Init();
        }

        private void Init() {
            if (E1.OK != Load()) {
                Create();
            }
        }

        public string GetPatternFilePath(string patternName = PatternConstants.FILE_NAME_PATTERN) {
            return Path.Combine(new string[] {
                PatternConstants.GetSubPatternDirPath(_patternInfo),
                patternName + FILE_EXT_PATTERN
            });
        }

        public int Load() {
            _paramExt = LoadParamExt();
            return E1.OK;
        }

        public int Save() {
            return SaveParamExt(_paramExt);
        }

        public int Create() {
            _paramExt = LoadParamExt();
            return E1.OK;
        }

        public int Remove() {
            var patternFilePath = GetPatternFilePath();
            var patternDirPath = Path.GetDirectoryName(patternFilePath);
            if (Directory.Exists(patternDirPath)) {
                Directory.Delete(patternDirPath, recursive: true);
            }

            return E1.OK;
        }

        public ROI GetFindROI() {
            // 수정 필요
            return new ROI();
        }

        public int SetFindROI(ROI findRoi) {
            throw new NotSupportedException();
        }

        public IRunParam GetRunParam() {
            return new LineWidthRunParam() {
                PatternId1 = _paramExt.PatternId1,
                PatternId2 = _paramExt.PatternId2
            };
        }

        public int SetRunParam(IRunParam runParam) {
            var param = runParam as LineWidthRunParam;
            if (param is null) {
                return E1.GENERIC;
            }
            _paramExt.PatternId1 = param.PatternId1;
            _paramExt.PatternId2 = param.PatternId2;

            return E1.OK;
        }

        public PatternResult Find(object image) {
            throw new NotSupportedException();
        }

        public PatternResult Find(object image, ROI findRoi) {
            throw new NotSupportedException();
        }

        public PatternResult GetNotFoundPatternResult() {
            return new PatternResult() {
                Status = eFoundStatus.NotFound,
                Results = new List<CaliperResult>()
            };
        }

        public object GetTool() {
            throw new NotImplementedException();
        }

        public void Draw(
            PatternResult patternResult, ICameraDisplay cameraDisplay, bool isFixturePattern = false) {
            var cogCameraDisplay = cameraDisplay as ICogCameraDisplay;

            // Line
            foreach (var result in patternResult.Results) {
                var caliperResult = result as CaliperResult;
                DrawLinePatternResult(patternResult, caliperResult.PatternResultFirst, cogCameraDisplay);
                DrawLinePatternResult(patternResult, caliperResult.PatternResultSecond, cogCameraDisplay);
            }

            // Cross
            if (patternResult.Status == eFoundStatus.FoundOK) {
                var crosses = new List<Cross>();

                foreach (BaseResult baseResult in patternResult.Results) {
                    var result = baseResult as CaliperResult;
                    var color = GraphicColors.PatternFoundOK;
                    var cross = new Cross(result.ImagePosition.Clone() as ImagePoint, 5);
                    crosses.Add(cross);

                    cogCameraDisplay.SetPatternTracking(cross);
                    cogCameraDisplay.AddCross(cross, color);

                    // Width
                    DrawLineWidth(result, cogCameraDisplay);

                    // Text
                    var msgs = new List<string>();
                    msgs.Add(string.Format("I({0:0.0}, {1:0.0})", result.ImagePosition.X, result.ImagePosition.Y));
                    msgs.Add(result.ConvertMaterialPosition());
                    msgs.Add(string.Format("Width[Px] : {0:0.000}", result.WidthPx));
                    msgs.Add(string.Format("Width : {0:0.000}", CoordUnitValueConverter.GetCoordUnitValue(result.WidthMm)));
                    msgs.Add(string.Format("TactTime : {0:0.000}", patternResult.TactTimeInMilliSec));
                    msgs.Add(string.Format("ID : {0}_{1}", patternResult.PatternIndex.PatternId, patternResult.PatternIndex.PatternSubId));

                    cogCameraDisplay.AddTextList(
                        CogColorConstants.Orange, new ImagePoint(result.ImagePosition.X + 15, result.ImagePosition.Y + 15), msgs);
                }
                cogCameraDisplay.DrawPatternTrackings(crosses);
            }
        }

        private void DrawLinePatternResult(PatternResult patternResult, PatternResult linePatternResult, ICogCameraDisplay cogCameraDisplay) {
            if (linePatternResult.Results != null) {
                foreach (var pr in linePatternResult.Results) {
                    var lineFinderResult = pr as LineFinderResult;
                    if (lineFinderResult != null) {
                        CogMeasureLine.Draw((CogFindLineTool)lineFinderResult.ContextId, patternResult, cogCameraDisplay);
                        CogMeasureLine.DrawCaliperROI((CogFindLineTool)lineFinderResult.ContextId, cogCameraDisplay, linePatternResult.FindRoi);
                    }
                }
            }
        }

        private void DrawLineWidth(CaliperResult caliperResult, ICogCameraDisplay cogCameraDisplay) {
            cogCameraDisplay.AddLine(CogColorConstants.Orange, caliperResult.ImagePosition, caliperResult.ImagePositionSecond_VI);
        }

        public Bitmap GetThumbnail() {
            throw new NotSupportedException();
        }

        #region IPatternBlock
        public List<int> GetPatternBlockIds() {
            return new List<int>() { _paramExt.PatternId1, _paramExt.PatternId2 };
        }

        public PatternResult Find(List<PatternResult> patternResults) {
            if (patternResults == null || patternResults.Count != 2) {
                return new PatternResult() {
                    Status = eFoundStatus.NotFound,
                    TactTimeInMilliSec = 0
                };
            }

            var caliperResults = new List<CaliperResult>();
            var line1Results = patternResults[0].Results as List<LineFinderResult>;
            var line2Results = patternResults[1].Results as List<LineFinderResult>;

            if (line1Results == null ||
                line2Results == null ||
                line1Results.Count != 1 ||
                line2Results.Count != 1) {

                caliperResults.Add(
                    new CaliperResult(
                        new ImagePoint(),
                        new ImagePoint(),
                        new ImagePoint(),
                        new LineEquation(1, 1, 1),
                        new LineEquation(1, 1, 1),
                        patternResults[0],
                        patternResults[1],
                        0));

                return new PatternResult() {
                    Status = eFoundStatus.NotFound,
                    Results = caliperResults,
                    TactTimeInMilliSec = 0
                };
            }

            var line1Result = line1Results[0];
            var line2Result = line2Results[0];

            caliperResults.Add(new CaliperResult(
                line1Result.ImagePosition,
                line2Result.ImagePosition,
                NativePattern.GetVerticalIntersectionPoint(line1Result.ImagePosition, line1Result.LineEquation, line2Result.LineEquation),
                line1Result.LineEquation,
                line2Result.LineEquation,
                patternResults[0],
                patternResults[1],
                NativePattern.GetDistancePointToLine(line1Result.ImagePosition, line2Result.LineEquation)));

            return new PatternResult() {
                Status = (patternResults.Count > 0) ? eFoundStatus.FoundOK : eFoundStatus.NotFound,
                Results = caliperResults,
                TactTimeInMilliSec = 0
            };
        }

        public Bitmap GetThumbnail(List<ROI> findRois) {
            if (findRois == null || findRois.Count != 2) {
                return ThumbnailUtil.GetDefaultImage();
            }

            try {
                var offsets = new List<ImagePoint>() {
                    new ImagePoint(0, 5),
                    new ImagePoint(0, -5)
                };

                var imageSize = ThumbnailUtil.GetImageSize();
                var center = new ImagePoint(imageSize.Width / 2, imageSize.Height / 2);
                var thumnailImage = new Bitmap(
                    imageSize.Width, imageSize.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                var pen = new Pen(new SolidBrush(Color.FromKnownColor(KnownColor.White)), 3);

                using (var graphics = Graphics.FromImage(thumnailImage)) {
                    for (int i = 0; i < findRois.Count; i++) {
                        var findRoi = findRois[i];
                        var lineStart = MathUtil.Rotate(new ImagePoint(0, (int)center.Y + offsets[i].Y), findRoi.Angle, center);
                        var lineEnd = MathUtil.Rotate(new ImagePoint(imageSize.Width, (int)center.Y + offsets[i].Y), findRoi.Angle, center);
                        graphics.DrawLine(
                            pen,
                            new Point((int)lineStart.X, (int)lineStart.Y),
                            new Point((int)lineEnd.X, (int)lineEnd.Y));
                    }
                }
                return thumnailImage;
            }
            catch (Exception e) {
                _logger.FuncE(e.Message);
            }

            return ThumbnailUtil.GetDefaultImage();
        }
        #endregion

        #region IDisposible
        public void Dispose() {
            FreeContexts();
        }

        private void FreeContexts() {
            //CogMeasureCommon.FreeContext(_contextId);
            //_contextId = MIL.M_NULL;
        }
        #endregion

        #region Line Width Specific
        public bool IsParamExtExist() {
            return PatternBlockParamExt.Exists(PatternConstants.GetSubPatternDirPath(_patternInfo));
        }

        public PatternBlockParamExt LoadParamExt() {
            return PatternBlockParamExt.Load(PatternConstants.GetSubPatternDirPath(_patternInfo));
        }

        public int SaveParamExt(PatternBlockParamExt patternBlockParam) {
            return PatternBlockParamExt.Save(
                PatternConstants.GetSubPatternDirPath(_patternInfo),
                patternBlockParam);
        }
        #endregion
    }
}