/*
  * 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.Drawing;
using System.Collections.Generic;

namespace CogPattern {
    /// <summary>
    /// Caliper 클래스
    /// </summary>
    public class Caliper : PatternBase, IPatternFinder, IDisposable {
        /// <inheritdoc/>
        public string FILE_EXT_PATTERN { get; set; } = "_Caliper.vpp";

        private readonly Logger _logger;
        private readonly PatternInfo _patternInfo;
        private CogCaliperTool _CogCaliperTool;
        /// <summary>
        /// Caliper 생성자
        /// </summary>
        /// <param name="patternInfo">패턴 정보</param>
        public Caliper(PatternInfo patternInfo) {
            _patternInfo = patternInfo;
            _logger = new Logger(
                $"Caliper_{patternInfo.GetPatternIndex()}");
            Init();
        }

        private void Init() {
            if (E1.OK != Load()) {
                Create();
            }
        }
        /// <summary>
        /// 패턴의 경로 가져오기
        /// </summary>
        /// <returns>문자열</returns>
        public string GetPatternFilePath(string patternName = PatternConstants.FILE_NAME_PATTERN) {
            return Path.Combine(new string[] {
                PatternConstants.GetSubPatternDirPath(_patternInfo),
                patternName + FILE_EXT_PATTERN
            });
        }
        /// <summary>
        /// 캘리퍼 불러오기
        /// </summary>
        /// <returns>성공유무</returns>
        public int Load() {
            var patternFilePath = GetPatternFilePath();

            if (!File.Exists(patternFilePath)) {
                _logger.I($"Pattern File does NOT exist : {patternFilePath}");
                return E2.NOT_FOUND;
            }

            _CogCaliperTool = CogMeasureWidth.LoadTool(patternFilePath);
            return E1.OK;
        }
        /// <summary>
        /// 캘리퍼 저장
        /// </summary>
        /// <returns>성공유무</returns>
        public int Save() {
            var patternFilePath = GetPatternFilePath();
            var patternDirPath = Path.GetDirectoryName(patternFilePath);
            if (!Directory.Exists(patternDirPath)) {
                Directory.CreateDirectory(patternDirPath);
            }

            return CogMeasureWidth.SaveTool(_CogCaliperTool, patternFilePath);
        }
        /// <summary>
        /// 캘리퍼 생성
        /// </summary>
        /// <returns>성공유무</returns>
        public int Create() {
            FreeTool();
            _CogCaliperTool = CogMeasureWidth.CreateTool();

            return E1.OK;
        }
        /// <summary>
        /// 캘리퍼 제거
        /// </summary>
        /// <returns>성공유무</returns>
        public int Remove() {
            FreeTool();

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

            return E1.OK;
        }
        /// <summary>
        /// ROI 가져오기
        /// </summary>
        /// <returns>ROI</returns>
        public ROI GetFindROI() {
            return CogMeasureWidth.GetFindROI(_CogCaliperTool);
        }
        /// <summary>
        /// ROI 설정
        /// </summary>
        /// <param name="findRoi">ROI</param>
        /// <returns>성공유무</returns>
        public int SetFindROI(ROI findRoi) {
            return CogMeasureWidth.SetFindROI(_CogCaliperTool, findRoi);
        }
        /// <summary>
        /// 실행인자 가져오기
        /// </summary>

        /// <returns>IRunParam</returns>
        public IRunParam GetRunParam() {
            return CogMeasureWidth.GetRunParam(_CogCaliperTool);
        }
        /// <summary>
        /// 실행인자 설정하기
        /// </summary>
        /// <param name="runParam">실행인자</param>
        /// <returns>성공유무</returns>
        public int SetRunParam(IRunParam runParam) {
            return CogMeasureWidth.SetRunParam(_CogCaliperTool, runParam);
        }
        /// <summary>
        /// 패턴 찾기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <returns>패턴결과</returns>
        public PatternResult Find(object image) {
            return CogMeasureWidth.Find(_CogCaliperTool, (ICogImage)image);
        }
        /// <summary>
        /// 패턴 찾기
        /// </summary>
        /// <param name="image">이미지</param>
        /// <param name="findRoi">ROI영역</param>
        /// <returns>PatternResult</returns>
        public PatternResult Find(object image, ROI findRoi) {
            return CogMeasureWidth.Find(_CogCaliperTool, (ICogImage)image, findRoi);
        }
        /// <summary>
        /// 결과없음 가져오기
        /// </summary>
        /// <returns>PatternResult</returns>
        public PatternResult GetNotFoundPatternResult() {
            return CogMeasureWidth.GetNotFoundPatternResult();
        }
        /// <summary>
        /// 캘리퍼 object로 가져오기
        /// </summary>
        /// <returns>object</returns>
        public object GetTool() {
            return _CogCaliperTool;
        }
        /// <summary>
        /// 결과 그리기
        /// </summary>
        /// <param name="patternResult">패턴결과</param>
        /// <param name="cameraDisplay">Display</param>
        /// <param name="isFixturePattern">픽스쳐 여무</param>
        public void Draw(
            PatternResult patternResult, ICameraDisplay cameraDisplay, bool isFixturePattern = false) {
            CogMeasureWidth.Draw(_CogCaliperTool, patternResult, cameraDisplay as ICogCameraDisplay);
        }
        /// <summary>
        /// 썸네일 가져오기
        /// </summary>
        /// <returns>비트맵</returns>
        public Bitmap GetThumbnail() {
            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);
                var findRoi = GetFindROI();

                using (var graphics = Graphics.FromImage(thumnailImage)) {
                    for (int i = 0; i < 2; 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();
        }

        #region IDisposible
        /// <summary>
        /// 자원 회수
        /// </summary>
        public void Dispose() {
            FreeTool();
        }

        private void FreeTool() {
            CogMeasureWidth.FreeTool(_CogCaliperTool);
        }
        #endregion
    }
}