using Aurora;
using Aurora.Api;
using MilCommon;
using VisionCommon;
using Hermes;
using Matrox.MatroxImagingLibrary;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reactive.Linq;

namespace MilPattern {
    public class CamPatternAgent : PatternAgentBase {
        private eCamId _camId;

        public CamPatternAgent(
            eCamId camId) : base() {
            _camId = camId;
            _logger = new Logger($"PA{_camId}");
            LoadPatterns();
        }

        public override Dictionary<PatternInfo, IPatternFinder> GetPatterns() {
            return _patterns;
        }

        #region Main Patterns
        public override List<PatternInfo> GetMainPatterns(SubSysInfo subSysInfo, eFovId fovId) {
            FovRecipe fovRecipe = VisionRecipeManager.GetFovRecipe(subSysInfo.UnitId, subSysInfo.SubSysId, fovId);
            return GetMainPatterns(CamPatternIndex.GetPrefix(fovRecipe.CamRecipe.CamId));
        }

        public override List<PatternInfo> GetMainPatterns(FovInfo fovInfo) {
            FovRecipe fovRecipe = VisionRecipeManager.GetFovRecipe(fovInfo);
            return GetMainPatterns(CamPatternIndex.GetPrefix(fovRecipe.CamRecipe.CamId));
        }
        #endregion

        public override PatternInfo GetPatternInfo(FovInfo fovInfo, int patternId) {
            var fovRecipe = VisionRecipeManager.GetFovRecipe(fovInfo.UnitId, fovInfo.SubSysId, fovInfo.FovId);
            return GetPatternInfo(new CamPatternIndex(fovRecipe.CamRecipe.CamId, patternId));
        }

        public override string GetPatternInfoPath() {
            return VisionSettingManager.VisionSetting.RootDirPath;
        }

        /// <summary>
        /// 패턴 가져오기
        /// </summary>
        /// <returns>패턴</returns>
        public override int LoadPatterns() {
            if (!MilEnvironment.Instance.HasValidLicense()) {
                _logger.I("No MIL license");
                return E1.GENERIC;
            }

            if (E1.OK != ClearPatterns(_patterns)) {
                return E1.GENERIC;
            }
            if (E1.OK != LoadPatterns(_patterns)) {
                return E1.GENERIC;
            }

            return E1.OK;
        }

        public override int CopyPattern(PatternIndex sourcePatternIndex, PatternIndex dstPatternIndex) {
            // 1. Copy
            string curRecipePath = GetPatternInfoPath();
            string sourcePatternPath = Path.Combine(new string[] {
                curRecipePath,
                PatternConstants.DIR_NAME_PATTERN,
                sourcePatternIndex.GetSubPatternDirectoryPath()
            });
            string dstPatternPath = Path.Combine(new string[] {
                curRecipePath,
                PatternConstants.DIR_NAME_PATTERN,
                dstPatternIndex.GetSubPatternDirectoryPath()
            });

            // 2. Remove old dst pattern
            if (E1.OK != Remove(dstPatternIndex)) {
                _logger.FuncE($"Remove error");
                return E1.GENERIC;
            }

            // 3. Copy pattern files
            if (E1.OK != CopyPatternFiles(sourcePatternPath, dstPatternPath)) {
                _logger.FuncE($"CopyPatternFiles error");
                return E1.GENERIC;
            }

            // 4. Reload copied pattern files
            var patternInfoFilePath = Path.Combine(dstPatternPath, PatternConstants.FILE_NAME_PATTERN_INFO);
            if (!File.Exists(patternInfoFilePath)) {
                _logger.FuncE($"patternInfoFilePath does NOT exist : {patternInfoFilePath}");
                return E1.GENERIC;
            }

            var sourcePatternInfo = GetPatternInfo(sourcePatternIndex);
            var dstPatternInfo = LoadPatternInfoFromFile(patternInfoFilePath);
            dstPatternInfo.MilSystemId = sourcePatternInfo.MilSystemId;
            dstPatternInfo.PatternIndex = dstPatternIndex.Clone() as CamPatternIndex;

            return ReloadPattern(dstPatternInfo);
        }

        public override object GetTool(PatternInfo patternInfo) {
            throw new NotImplementedException();    // 미사용
        }

        #region Find for Sequence
        public override PatternResult FindPattern(
            PatternInfo patternInfo, object image, ICameraDisplay cameraDisplay, FixtureResult fixtureResult) {
            var findImage = (MIL_ID)image;
            var patternResult = new PatternResult();
            var pattern = _patterns[patternInfo];

            if (((PatternBase)pattern).IsDirty()) {
                ((PatternBase)pattern).CleanDirty();
                pattern.Load();
            }

            ROI fixtureRoi = GetFixtureROI(patternInfo, fixtureResult);
            patternResult.FindRoi = fixtureRoi.Clone() as ROI;

            if (!patternInfo.IsActivated) {
                _logger.I($"{patternInfo} : NOT activated");
                patternResult = pattern.GetNotFoundPatternResult();
            }
            else {
                if (patternInfo.PreProcParam.Enabled()) {
                    MIL_ID preProcImage = MIL.M_NULL;
                    try {
                        preProcImage = ImgPreProcessor.GetPreProcessedImage(findImage, patternInfo.PreProcParam);
                        patternResult = Find(patternInfo, preProcImage, fixtureRoi);
                        CopyImageToDisplay(cameraDisplay as IMilCameraDisplay, preProcImage);
                    }
                    catch (Exception e) {
                        _logger.I($"{e.Message}");
                    }
                    finally {
                        MilEnvironment.FreeImage(preProcImage);
                    }
                }
                else {
                    patternResult = Find(patternInfo, findImage, fixtureRoi);
                }
            }

            if (patternResult.Status == eFoundStatus.FoundOK) {
                foreach (var reuslt in patternResult.Results) {
                    _logger.I($"{patternInfo} : {patternResult.Status} : {reuslt}");
                }
            }
            else {
                _logger.I($"{patternInfo} : {patternResult.Status}");
            }

            SetPatternParams(patternInfo, patternResult);

            if (patternResult.PatternType == ePatternType.LineFinder) {
                SetLineCenterPoint(patternResult, patternInfo, cameraDisplay);
            }

            return patternResult;
        }

        private void CopyImageToDisplay(IMilCameraDisplay milCameraDisplay, MIL_ID preProcImage) {
            var displayImage = milCameraDisplay.GetImage();
            if (MilEnvironment.ImageSizeEquals(preProcImage, displayImage)) {
                MilEnvironment.CopyImage(preProcImage, displayImage);
            }
        }
        #endregion

        #region TestFind for Pattern Registration
        public override PatternResult FindPattern(PatternInfo patternInfo, object image, ROI findRoi = null) {
            var findImage = (MIL_ID)image;
            var patternResult = new PatternResult() {
                PatternIndex = patternInfo.GetPatternIndex().Clone() as PatternIndex,
            };

            if (_patterns.ContainsKey(patternInfo)) {
                if (patternInfo.IsActivated) {
                    var pattern = _patterns[patternInfo];
                    if (findRoi == null) {
                        patternResult = pattern.Find(findImage);
                    }
                    else {
                        patternResult = pattern.Find(findImage, findRoi);
                    }

                    patternResult.FindRoi = (findRoi != null) ? findRoi : GetFindROI(patternInfo);
                }
                else {
                    _logger.I($"Pattern is not activated.");
                }
            }
            else {
                _logger.I($"Pattern does not exist.");
            }

            SetPatternParams(patternInfo, patternResult);

            return patternResult;
        }

        public override PatternResult FindPatternBlock(PatternInfo patternInfo, object image, ROI findRoi = null) {
            var findImage = (MIL_ID)image;
            var patternResult = new PatternResult() {
                PatternIndex = patternInfo.GetPatternIndex().Clone() as PatternIndex,
            };

            if (_patterns.ContainsKey(patternInfo)) {
                if (patternInfo.IsActivated) {
                    var pattern = _patterns[patternInfo];
                    var patternBlock = pattern as IPatternBlock;
                    var patternBlockResults = new List<PatternResult>();
                    foreach (var patternId in patternBlock.GetPatternBlockIds()) {
                        var curPatternIndex = patternInfo.GetPatternIndex().Clone() as PatternIndex;
                        curPatternIndex.PatternId = patternId;
                        var patterBlockPatternInfo = GetPatternInfo(curPatternIndex);
                        var curPattern = GetPattern(patterBlockPatternInfo);
                        PatternResult curPatternResult;
                        if (findRoi == null) {
                            curPatternResult = curPattern.Find(findImage);
                        }
                        else {
                            curPatternResult = curPattern.Find(findImage, findRoi);
                        }

                        curPatternResult.FindRoi = (findRoi != null) ? findRoi : GetFindROI(patterBlockPatternInfo);
                        patternBlockResults.Add(curPatternResult);
                    }
                    patternResult = patternBlock.Find(patternBlockResults);
                    patternResult.FindRoi = (findRoi != null) ? findRoi : GetFindROI(patternInfo);
                }
                else {
                    _logger.I($"Pattern is not activated.");
                }
            }
            else {
                _logger.I($"Pattern does not exist.");
            }

            SetPatternParams(patternInfo, patternResult);

            return patternResult;
        }
        #endregion

        public override void Draw(
            PatternInfo patternInfo, PatternResult patternResult, ICameraDisplay cameraDisplay, bool isFixturePattern = false) {
            if (_patterns.ContainsKey(patternInfo)) {
                var milCameraDisplay = cameraDisplay as IMilCameraDisplay;
                IPatternFinder pattern;
                if (patternResult.Status != eFoundStatus.NotFound &&
                    patternResult.PatternIndex != null) {
                    pattern = GetPattern(patternResult.PatternIndex);
                }
                else {
                    pattern = _patterns[patternInfo];
                }

                if (PatternConstants.IsPatternBlock(patternInfo.PatternType)) {
                    DrawPatternBlockResult(pattern, patternResult, milCameraDisplay, isFixturePattern);
                }
                else {
                    DrawPatternResult(pattern, patternResult, milCameraDisplay, isFixturePattern);
                }
            }
        }

        private void DrawPatternResult(
            IPatternFinder pattern, PatternResult patternResult, IMilCameraDisplay milCameraDisplay, bool isFixturePattern) {
            DrawFindROI(patternResult, milCameraDisplay, isFixturePattern);
            pattern.Draw(patternResult, milCameraDisplay, isFixturePattern);
        }

        private void DrawPatternBlockResult(
            IPatternFinder pattern, PatternResult patternResult, IMilCameraDisplay milCameraDisplay, bool isFixturePattern) {
            foreach (var patternBlockResult in patternResult.Results) {
                PatternResult line1PatternResult = null;
                PatternResult line2PatternResult = null;

                if (patternBlockResult.GetType() == typeof(LineIntersectionResult)) {
                    var intersectionResult = patternBlockResult as LineIntersectionResult;
                    line1PatternResult = intersectionResult.Line1PatternResult;
                    line2PatternResult = intersectionResult.Line2PatternResult;
                }
                else if (patternBlockResult.GetType() == typeof(CaliperResult)) {
                    var caliperResult = patternBlockResult as CaliperResult;
                    line1PatternResult = caliperResult.PatternResultFirst;
                    line2PatternResult = caliperResult.PatternResultSecond;
                }

                DrawFindROI(line1PatternResult, milCameraDisplay, isFixturePattern);
                DrawFindROI(line2PatternResult, milCameraDisplay, isFixturePattern);
                pattern.Draw(patternResult, milCameraDisplay, isFixturePattern);
            }
        }

        private void DrawFindROI(
            PatternResult patternResult, IMilCameraDisplay milCameraDisplay, bool isFixturePattern) {
            MIL_INT color = MIL.M_NULL;
            if (patternResult == null) {
                return;
            }
            if (patternResult.PatternType == ePatternType.Brightness && patternResult.Status == eFoundStatus.FoundOK) {
                color = ColorConverter.ConvertColor(eColor.Magenta);
            }
            else if (patternResult.PatternType == ePatternType.MultiLineFinder) {
                foreach (LineFinderResult lineFinderResult in patternResult.Results) {
                    color = GraphicColors.GetFindRoiColor(lineFinderResult.Status, isFixturePattern);
                    milCameraDisplay.AddPatternResultFindRoi(color, lineFinderResult.FindRoi);
                }
                return;
            }
            else {
                color = GraphicColors.GetFindRoiColor(patternResult.Status, isFixturePattern);
            }
            milCameraDisplay.AddPatternResultFindRoi(color, patternResult.FindRoi);
        }

        public override IPatternFinder CreatePattern(PatternInfo patternInfo) {
            switch (patternInfo.PatternType) {
                case ePatternType.ImageModelFinder:
                    return new ImageModelFinder(patternInfo);
                case ePatternType.ShapeModelFinder:
                    return new ShapeModelFinder(patternInfo);
                case ePatternType.PatternMatching:
                    return new PatternMatching(patternInfo);
                case ePatternType.LineFinder:
                    return new LineFinder(patternInfo);
                case ePatternType.MultiLineFinder:
                    return new MultiLineFinder(patternInfo);
                case ePatternType.Caliper:
                    return new Caliper(patternInfo);
                case ePatternType.EdgeFinder:
                    return new EdgeFinder(patternInfo);
                case ePatternType.Blob:
                    return new Blob(patternInfo);
                case ePatternType.BarCode:
                    return new BarCodeReader(patternInfo);
                case ePatternType.Brightness:
                    return new Brightness(patternInfo);
                case ePatternType.LineIntersection:
                    return new LineIntersection(patternInfo);
                case ePatternType.LineWidth:
                    return new LineWidth(patternInfo);
                case ePatternType.MachinePattern_A:
                case ePatternType.MachinePattern_B:
                case ePatternType.MachinePattern_C:
                    return EquipAdapter.Instance.MachinePatternManager.GetPattern(patternInfo);
            }

            _logger.E($"No matching of PatternType : {patternInfo.PatternType}");
            return null;
        }

        public override List<PatternInfo> GetPatternInfoListFromFiles(string curRecipePath) {
            var patternInfoList = new List<PatternInfo>();

            for (int patternId = 0; patternId < PatternConstants.CAM_PATTERN_COUNT; patternId++) {
                var patternDirPath = Path.Combine(
                    curRecipePath,
                    PatternConstants.DIR_NAME_PATTERN,
                    ((int)_camId).ToString(),
                    patternId.ToString());

                if (Directory.Exists(patternDirPath)) {
                    var patternDirPathList = Directory.GetDirectories(patternDirPath, "??", SearchOption.TopDirectoryOnly);

                    foreach (var subPatternDirPath in patternDirPathList) {
                        if (Directory.Exists(subPatternDirPath)) {
                            var patternInfoFilePath = Path.Combine(subPatternDirPath, PatternConstants.FILE_NAME_PATTERN_INFO);

                            if (File.Exists(patternInfoFilePath)) {
                                var patternInfo = LoadPatternInfoFromFile(patternInfoFilePath);
                                patternInfo.MilSystemId = GetMilSystemId(_camId);
                                patternInfo.PatternIndex = new CamPatternIndex(
                                    _camId,
                                    patternId,
                                    Convert.ToInt32(Path.GetFileName(subPatternDirPath)));
                                patternInfoList.Add(patternInfo);
                            }
                        }
                    }
                }
            }

            return patternInfoList;
        }

#warning FOV & CAM Pattern 분리
        private CamPatternInfo LoadPatternInfoFromFile(string filePath) {
            return JsonConvert.DeserializeObject(
                File.ReadAllText(filePath), typeof(CamPatternInfo)) as CamPatternInfo;
        }

        public static int GetMilSystemId(eCamId camId) {
            var camConfig = VisionEnv.AuroraEnv.DeviceManager.GetDeviceConfig(camId.ToString()) as CamConfig;
            if (camConfig != null) {
                return (int)MilEnvironment.Instance.GetSystem(camConfig.CamConnConfig.BoardType, camConfig.CamConnConfig.BoardSlotPos);
            }
            else {
                return 0;
            }
        }

        private Dictionary<T, U> SortDictionary<T, U>(Dictionary<T, U> dict) {
            return dict.OrderBy(item => item.Key).ToDictionary(x => x.Key, x => x.Value);
        }

        public override int GetFindNumber(PatternInfo patternInfo) {
            if (patternInfo.PatternType == ePatternType.ImageModelFinder) {
                ImageModelFinder imageModelFinder = new ImageModelFinder(patternInfo);
                return (imageModelFinder.GetFindNumber());
            }
            else if (patternInfo.PatternType == ePatternType.ShapeModelFinder) {
                ShapeModelFinder shapeModelFinder = new ShapeModelFinder(patternInfo);
                return (shapeModelFinder.GetFindNumber());
            }
            else if (patternInfo.PatternType == ePatternType.PatternMatching) {
                PatternMatching patternMatching = new PatternMatching(patternInfo);
                return (patternMatching.GetFindNumber());
            }
            else {
                return 1;
            }
        }

        public override bool IsTrainPattern(PatternInfo patternInfo) {
            var pattern = GetPattern(patternInfo);
            if (pattern is IPatternTrain) {
                return true;
            }
            else {
                return false;
            }
        }
    }
}