/*
  * Copyright (c) 2025 LG Electronics Inc.
   * SPDX-License-Identifier: LicenseRef-LGE-Proprietary
   */
using Aurora.Api;
using MilCommon;
using VisionCommon;
using Hermes;
using Matrox.MatroxImagingLibrary;
using System;
using System.Collections.Generic;
using Aurora.Api.DataType;

namespace MilPattern {
    public class CaliperRunParam : IRunParam, ICloneable {
        public ePolarity PolarityFirst { get; set; } = ePolarity.Any;
        public ePolarity PolaritySecond { get; set; } = ePolarity.Opposite;
        public int SubRegionNumber { get; set; } = 8;
        public double MinEdgeValue { get; set; } = 2.0;
        public Angle AngleTolerance { get; set; } = Angle.CreateWithDegree(5);
        public ROI FindROI { get; set; }

        public object Clone() {
            return new CaliperRunParam() {
                SubRegionNumber = SubRegionNumber,
                PolarityFirst = PolarityFirst,
                PolaritySecond = PolaritySecond,
                FindROI = FindROI.Clone() as ROI
            };
        }
    }

    internal class MilMeasureWidth {
        private static Logger _Logger = new Logger(typeof(MilMeasureWidth).Name);

        public static MIL_ID CreateContext(MIL_ID milSystem) {
            return MilMeasureCommon.CreateContext(milSystem, MIL.M_STRIPE);
        }

        public static IRunParam GetRunParam(MIL_ID contextId) {
            var runParam = new CaliperRunParam();
            int polarityFirst = 0;
            int polaritySecond = 0;
            MIL.MmeasInquire(contextId, MIL.M_POLARITY + MIL.M_TYPE_MIL_INT, ref polarityFirst, ref polaritySecond);
            runParam.PolarityFirst = (ePolarity)polarityFirst;
            runParam.PolaritySecond = (ePolarity)polaritySecond;
            // default : ePolarity.Opposite -> ePolarity.Any
            runParam.PolaritySecond = runParam.PolaritySecond == ePolarity.Opposite ? ePolarity.Any : runParam.PolaritySecond;

            runParam.SubRegionNumber =
                    (int)MIL.MmeasInquire(contextId, MIL.M_SUB_REGIONS_NUMBER, MIL.M_NULL, MIL.M_NULL);
            runParam.FindROI = MilMeasureCommon.GetFindROI(contextId);

            return runParam;
        }

        public static int SetRunParam(MIL_ID contextId, IRunParam runParam) {
            if (runParam is CaliperRunParam) {
                var param = runParam as CaliperRunParam;
                MIL.MmeasSetMarker(contextId, MIL.M_SUB_REGIONS_NUMBER, param.SubRegionNumber, MIL.M_NULL);
                MIL.MmeasSetMarker(contextId, MIL.M_POLARITY, (double)param.PolarityFirst, (double)param.PolaritySecond);
                MIL.MmeasSetMarker(contextId, MIL.M_EDGEVALUE_MIN, param.MinEdgeValue, MIL.M_NULL);
                MIL.MmeasSetMarker(contextId, MIL.M_BOX_ANGLE_TOLERANCE, param.AngleTolerance.Degree, MIL.M_NULL);
                MilMeasureCommon.SetFindROI(contextId, param.FindROI);

                // Internal Param
                MIL.MmeasSetMarker(contextId, MIL.M_NUMBER, MIL.M_DEFAULT, MIL.M_NULL);
                MIL.MmeasSetMarker(contextId, MIL.M_FILTER_TYPE, MIL.M_SHEN, MIL.M_NULL);
                MIL.MmeasSetMarker(contextId, MIL.M_SEARCH_REGION_INPUT_UNITS, MIL.M_PIXEL, MIL.M_NULL);
                MIL.MmeasSetScore(
                    contextId, MIL.M_STRIPE_WIDTH_SCORE,
                    0.0, 0.0, MIL.M_MAX_POSSIBLE_VALUE, MIL.M_MAX_POSSIBLE_VALUE,
                    MIL.M_DEFAULT, MIL.M_DEFAULT, MIL.M_DEFAULT);

                return E1.OK;
            }

            return E1.GENERIC;
        }

        public static PatternResult Find(MIL_ID contextId, MIL_ID image, IRunParam runParam) {
            SetRunParam(contextId, runParam);

            return Find(contextId, image);
        }

        public static PatternResult Find(MIL_ID contextId, MIL_ID image, ROI findRoi) {
            return MilMeasureCommon.Find(contextId, image, ExtractResults, findRoi);
        }

        public static PatternResult Find(MIL_ID contextId, MIL_ID image) {
            return MilMeasureCommon.Find(contextId, image, ExtractResults);
        }

        private static PatternResult ExtractResults(MIL_ID contextId, double tactTime) {
            var results = new List<CaliperResult>();
            MIL_INT numOfResult = 0;
            MIL.MmeasGetResult(contextId, MIL.M_NUMBER + MIL.M_TYPE_MIL_INT, ref numOfResult);

            if (0 < numOfResult) {
                double positionFirstX = 0;
                double positionFirstY = 0;
                MIL.MmeasGetResult(contextId, MIL.M_POSITION + MIL.M_EDGE_FIRST, ref positionFirstX, ref positionFirstY);
                var positionFirst = new ImagePoint(positionFirstX, positionFirstY);

                double positionSecondX = 0;
                double positionSecondY = 0;
                MIL.MmeasGetResult(contextId, MIL.M_POSITION + MIL.M_EDGE_SECOND, ref positionSecondX, ref positionSecondY);
                var positionSecond = new ImagePoint(positionSecondX, positionSecondY);

                double widthPx = 0;
                MIL.MmeasGetResult(contextId, MIL.M_STRIPE_WIDTH, ref widthPx);

                results.Add(new CaliperResult(
                    positionFirst,
                    positionSecond,
                    new ImagePoint(),
                    GetLineEquation(contextId, MIL.M_EDGE_FIRST),
                    GetLineEquation(contextId, MIL.M_EDGE_SECOND),
                    new PatternResult(),
                    new PatternResult(),
                    widthPx));
            }

            return new PatternResult() {
                Status = (results.Count > 0) ? eFoundStatus.FoundOK : eFoundStatus.NotFound,
                Results = results,
                TactTimeInMilliSec = MathUtil.ConvertUnitSecToMilli(tactTime)
            };
        }

        private static LineEquation GetLineEquation(MIL_ID contextId, MIL_INT lineIndex) {
            double lineA = 0, lineB = 0, lineC = 0;
            MIL.MmeasGetResult(contextId, MIL.M_LINE_A + lineIndex, ref lineA);
            MIL.MmeasGetResult(contextId, MIL.M_LINE_B + lineIndex, ref lineB);
            MIL.MmeasGetResult(contextId, MIL.M_LINE_C + lineIndex, ref lineC);

            return new LineEquation(lineA, lineB, lineC);
        }

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

        public static void Draw(MIL_ID contextId, PatternResult patternResult, IMilCameraDisplay milCameraDisplay) {
            MilMeasureCommon.DrawSubPositions(contextId, milCameraDisplay);
            DrawLines(patternResult, milCameraDisplay);
            DrawText(patternResult, milCameraDisplay);
            DrawWidth(patternResult, milCameraDisplay);
        }

        private static void DrawLines(PatternResult patternResult, IMilCameraDisplay milCameraDisplay) {
            var imageSize = MilEnvironment.GetImageSize(milCameraDisplay.GetImage());
            var lines = new List<Line<ImagePoint>>();
            foreach (BaseResult baseResult in patternResult.Results) {
                var caliperResult = baseResult as CaliperResult;
                lines.Add(MilMeasureCommon.GetMinLengthLine(caliperResult.LineEquationFirst, imageSize));
                lines.Add(MilMeasureCommon.GetMinLengthLine(caliperResult.LineEquationSecond, imageSize));
            }
            milCameraDisplay.AddLines(GraphicColors.PatternFoundOK, lines);
        }

        private static void DrawText(PatternResult patternResult, IMilCameraDisplay milCameraDisplay) {
            if (patternResult.Status == eFoundStatus.FoundOK) {
                foreach (BaseResult baseResult in patternResult.Results) {
                    var caliperResult = baseResult as CaliperResult;
                    DrawText(caliperResult, milCameraDisplay);
                }
            }
        }

        private static void DrawText(CaliperResult caliperResult, IMilCameraDisplay milCameraDisplay) {
            if (caliperResult != null) {
                var msgs = new List<string>();
                msgs.Add(string.Empty);
                msgs.Add(string.Format("Width : {0:0.00} px", caliperResult.WidthPx));
                msgs.Add(string.Format("Width : {0:0.00} mm", caliperResult.WidthMm));
                milCameraDisplay.AddTextList(
                    GraphicColors.PatternFoundOK, new ImagePoint(caliperResult.ImagePosition.X, caliperResult.ImagePosition.Y), msgs);
            }
        }

        private static void DrawWidth(PatternResult patternResult, IMilCameraDisplay milCameraDisplay) {
            foreach (BaseResult baseResult in patternResult.Results) {
                var caliperResult = baseResult as CaliperResult;
                var lines = new List<Line<ImagePoint>>() {
                        new Line<ImagePoint>(
                            caliperResult.ImagePosition,
                            caliperResult.ImagePositionSecond)
                    };
                milCameraDisplay.AddVectors(GraphicColors.PatternFoundOK, lines, true);
            }
        }
    }
}