using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using CameraVisionLib.Model;

namespace Asa.Camera
{
    /// <summary>
    /// 视觉库
    /// </summary>
    public partial class VisionLib : IDisposable
    {
        internal ScanParam scanParam;
        internal Dictionary<string, List<RegionPlan>> regionLists;
        internal List<IPCameraInfo> ipCameraInfos;
        private ICamera[] cameraAll;
        private readonly Barcode.Identify identify;



        /// <summary>
        /// 视觉库
        /// </summary>
        /// <param name="configPath"></param>
        /// <param name="preload"></param>
        /// <param name="logName"></param>
        public VisionLib(string configPath, bool preload = true, string logName = "CameraVisionLib")
        {

            Common.log = log4net.LogManager.GetLogger(logName);
            GetConfig(configPath);
            identify = new(scanParam);

            cameraAll = new ICamera[2];  // 3种类型的相机
            cameraAll[0] = new HIK.IPCamera(ipCameraInfos);
            cameraAll[1] = new HIK.VisionCamera();
            //cameraAll[2] = new Basler.VisionCamera();

            if (preload)
            {
                string s = "Load Camera";
                for (int i = 0; i < cameraAll.Length; i++)
                {
                    bool rtn = cameraAll[i].Load();
                    Count += cameraAll[i].Count;
                    s += ", " + cameraAll[i].GetType().FullName + ":" + rtn.ToString();
                }
                Common.log.Info(s);
            }
        }

        /// <summary>
        /// 释放
        /// </summary>
        public void Dispose()
        {
            for (int i = 0; i < cameraAll.Length; i++)
                cameraAll[i].Dispose();
            Common.log.Info("Dispose Camera");
        }

        /// <summary>
        /// 相机数量
        /// </summary>
        public int Count { private set; get; } = 0;

        /// <summary>
        /// 加载相机，有预加载了就不需要调用
        /// </summary>
        public void Load()
        {
            cameraAll = new ICamera[2];  // 3种类型的相机
            cameraAll[0] = new HIK.IPCamera(ipCameraInfos);
            cameraAll[1] = new HIK.VisionCamera();
            //cameraAll[2] = new Basler.VisionCamera();

            string s = "Load Camera";
            for (int i = 0; i < cameraAll.Length; i++)
            {
                bool rtn = cameraAll[i].Load();
                Count += cameraAll[i].Count;
                s += ", " + cameraAll[i].GetType().FullName + ":" + rtn.ToString();
            }
            Common.log.Info(s);
        }

        /// <summary>
        /// 另存为配置文件
        /// </summary>
        /// <param name="path"></param>
        public void SaveAsConfig(string path)
        {
            System.Web.Script.Serialization.JavaScriptSerializer serializer = new();
            Dictionary<string, object> dic = new();
            dic.Add("CodeOrder", Common.visionLib.scanParam.CodeOrder.ToString());
            dic.Add("Halcon", new Dictionary<string, object>
            {
                { "CodeType", Common.visionLib.scanParam.HalconType.ToString() },
                { "Zoom1DCode", Common.visionLib.scanParam.Zoom1D },
                { "Zoom2DCode", Common.visionLib.scanParam.Zoom2D }
            });

            dic.Add("EyemLib", new Dictionary<string, object>
            {
                { "CodeType", Common.visionLib.scanParam.EyemType.ToString() },
                { "BlockSize", Common.visionLib.scanParam.EyemBlockSize },
                { "RangeC", Common.visionLib.scanParam.EyemRangeC },
                { "SymbolMin", Common.visionLib.scanParam.EyemSymbolMin },
                { "SymbolMax", Common.visionLib.scanParam.EyemSymbolMax }
            });

            Dictionary<string, object> cameraList = new();
            foreach (string cameraKey in regionLists.Keys)
            {
                Dictionary<string, object> plan = new();
                for (int i = 0; i < regionLists[cameraKey].Count; i++)
                {
                    List<RegionInfo> info = regionLists[cameraKey][i].Info;
                    object[] infoList = new object[info.Count];
                    for (int j = 0; j < info.Count; j++)
                    {
                        infoList[j] = new Dictionary<string, object>
                        {
                            { "RegionName", info[j].Name },
                            { "X", info[j].Region.X },
                            { "Y", info[j].Region.Y },
                            { "Width", info[j].Region.Width },
                            { "Height", info[j].Region.Height },
                            { "Ratio", Convert.ToSingle(info[j].Region.Ratio) }
                        };
                    }
                    plan.Add(regionLists[cameraKey][i].Name, infoList);
                }
                cameraList.Add(cameraKey, plan);
            }
            dic.Add("Region", cameraList);

            object[] obj = new object[ipCameraInfos.Count];
            for (int i = 0; i < obj.Length; i++)
            {
                obj[i] = new Dictionary<string, object>
                {
                    { "Name", ipCameraInfos[i].Name },
                    { "IP", ipCameraInfos[i].IP },
                    { "User", ipCameraInfos[i].User },
                    { "Password", ipCameraInfos[i].Password },
                    { "Port", ipCameraInfos[i].Port }
                };
            }
            dic.Add("HIKIPCamera", obj);

            string json = serializer.Serialize(dic);
            System.IO.File.WriteAllText(path, json, System.Text.Encoding.UTF8);
        }

        /// <summary>
        /// 获取相机名称
        /// </summary>
        /// <returns></returns>
        public string[] GetCameraName()
        {
            List<string> name = new();
            for (int i = 0; i < cameraAll.Length; i++)
                name.AddRange(cameraAll[i].Name);
            return name.ToArray();
        }

        /// <summary>
        /// 打开
        /// </summary>
        public void Open()
        {
            string s = "Open Camera";
            for (int i = 0; i < cameraAll.Length; i++)
            {
                bool rtn = cameraAll[i].OpenAll();
                s += ", " + cameraAll[i].GetType().FullName + ":" + rtn.ToString();
            }
            Common.log.Info(s);
        }

        /// <summary>
        /// 打开
        /// </summary>
        /// <param name="cameraName"></param>
        public void Open(string cameraName)
        {
            string s = "Open Camera " + cameraName;
            for (int i = 0; i < cameraAll.Length; i++)
            {
                bool rtn = cameraAll[i].Open(cameraName);
                s += ", "  + rtn.ToString();
                if (rtn) break;
            }
            Common.log.Info(s);
        }

        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            for (int i = 0; i < cameraAll.Length; i++)
                cameraAll[i].CloseAll();
            Common.log.Info("Close Camera");
        }

        /// <summary>
        /// 关闭
        /// </summary>
        /// <param name="cameraName"></param>
        public void Close(string cameraName)
        {
            for (int i = 0; i < cameraAll.Length; i++)
                cameraAll[i].Close(cameraName);
            Common.log.Info("Close Camera " + cameraName);
        }

        /// <summary>
        /// 获取当前图像
        /// </summary>
        /// <returns></returns>
        public Bitmap[] GetImage()
        {
            List<Bitmap> result = new();
            for (int i = 0; i < cameraAll.Length; i++)
            {
                if (cameraAll[i].Count == 0) continue;
                cameraAll[i].GrabOne(out Bitmap[] bmp);
                result.AddRange(bmp);
            }
            return result.ToArray();
        }

        /// <summary>
        /// 获取当前图像
        /// </summary>
        /// <param name="cameraName"></param>
        /// <returns></returns>
        public Bitmap GetImage(string cameraName)
        {
            for (int i = 0; i < cameraAll.Length; i++)
            {
                bool rtn = cameraAll[i].GrabOne(cameraName, out Bitmap bmp);
                if (rtn) return bmp;
            }
            return null;
        }

        /// <summary>
        /// 保存当前图像
        /// </summary>
        /// <param name="path">文件夹路径</param>
        /// <param name="fileName">文件名，不带扩展名</param>
        /// <param name="format">图像类型</param>
        public void SaveImage(string path, string fileName, ImageFormat format)
        {
            if (!System.IO.Directory.Exists(path)) return;
            string filePath = path.EndsWith("\\") ? path : path + "\\";
            filePath += fileName + "_{0}." + format.ToString();

            try
            {
                for (int i = 0; i < cameraAll.Length; i++)
                {
                    if (cameraAll[i].Count == 0) continue;
                    cameraAll[i].GrabOne(out Bitmap[] bmp);
                    
                    for (int j = 0; j < bmp.Length; j++)
                    {
                        if (bmp[j] == null) continue;
                        string filename = string.Format(filePath, j + 1);
                        bmp[j].Save(filename, format);
                        Common.log.Info("SaveImage " + filePath);
                    }
                }
            }
            catch (Exception ex)
            {
                Common.log.Error("SaveImage", ex);
            }
        }

        /// <summary>
        /// 保存当前图像
        /// </summary>
        /// <param name="cameraName">相机名称</param>
        /// <param name="path">文件夹路径</param>
        /// <param name="fileName">文件名，不带扩展名</param>
        /// <param name="format">图像类型</param>
        public void SaveImage(string cameraName, string path, string fileName, ImageFormat format)
        {
            if (!System.IO.Directory.Exists(path)) return;
            string filePath = path.EndsWith("\\") ? path : path + "\\";
            filePath += fileName + "." + format.ToString();

            try
            {
                for (int i = 0; i < cameraAll.Length; i++)
                {
                    bool rtn = cameraAll[i].GrabOne(cameraName, out Bitmap bmp);
                    if (rtn)
                    {
                        bmp.Save(filePath, format);
                        Common.log.Info("SaveImage " + filePath);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Common.log.Error("SaveImage", ex);
            }
        }

        /// <summary>
        /// 预览图像，目前仅支持 HIK.IPCamera
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="handle"></param>
        public void PreviewImage(string cameraName, IntPtr handle)
        {
            for (int i = 0; i < cameraAll.Length; i++)
            {
                if (cameraAll[i] is HIK.IPCamera)
                {
                    bool rtn = cameraAll[i].PreviewImage(cameraName, handle);
                    if (rtn) break;
                }
            }
        }





        /// <summary>
        /// 从相机图像获取条码
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public string[] GetBarCodeText(out List<Bitmap> image)
        {
            List<BarcodeInfo> info = new();
            image = new();

            for (int i = 0; i < cameraAll.Length; i++)
            {
                if (cameraAll[i].Count == 0) continue;
                cameraAll[i].GrabOne(out Bitmap[] bmp);
                image.AddRange(bmp);
                for (int j = 0; j < bmp.Length; j++)
                {
                    if (bmp[j] == null) continue;
                    info.AddRange(identify.GetCode(bmp[j]));
                }
            }

            List<string> code = new();
            for (int i = 0; i < info.Count; i++)
                code.Add(info[i].Text);

            return code.ToArray();
        }

        /// <summary>
        /// 从相机图像获取条码
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="image"></param>
        /// <returns></returns>
        public string[] GetBarCodeText(string cameraName, out Bitmap image)
        {
            List<BarcodeInfo> info = new();
            image = null;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                bool rtn = cameraAll[i].GrabOne(cameraName, out image);
                if (rtn)
                {
                    info.AddRange(identify.GetCode(image));
                    break;
                }
            }

            List<string> code = new();
            for (int i = 0; i < info.Count; i++)
                code.Add(info[i].Text);

            return code.ToArray();
        }

        /// <summary>
        /// 从给定的图像中获取条码文本
        /// </summary>
        /// <param name="bmp"></param>
        /// <returns></returns>
        public string[] GetBarCodeText(Bitmap bmp)
        {
            List<BarcodeInfo> info = identify.GetCode(bmp);
            List<string> code = new();

            for (int i = 0; i < info.Count; i++)
                code.Add(info[i].Text);

            return code.ToArray();
        }

        /// <summary>
        /// 从给定的条码中获取条码文本
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public string[] GetBarCodeText(List<BarcodeInfo> info)
        {
            List<string> code = new();
            for (int i = 0; i < info.Count; i++)
                code.Add(info[i].Text);
            return code.ToArray();
        }

        /// <summary>
        /// 从相机图像获取条码
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public List<BarcodeInfo> GetBarCode(out List<Bitmap> image)
        {
            List<BarcodeInfo> info = new();
            image = new();

            for (int i = 0; i < cameraAll.Length; i++)
            {
                if (cameraAll[i].Count == 0) continue;
                cameraAll[i].GrabOne(out Bitmap[] bmp);
                image.AddRange(bmp);

                for (int j = 0; j < bmp.Length; j++)
                {
                    if (bmp[j] == null) continue;
                    info.AddRange(identify.GetCode(bmp[j]));
                }
            }

            return info;
        }

        /// <summary>
        /// 从相机图像获取条码
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="image"></param>
        /// <returns></returns>
        public List<BarcodeInfo> GetBarCode(string cameraName, out Bitmap image)
        {
            List<BarcodeInfo> info = new();
            image = null;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                bool rtn = cameraAll[i].GrabOne(cameraName, out image);
                if (rtn)
                {
                    info.AddRange(identify.GetCode(image));
                    break;
                }
            }

            return info;
        }

        /// <summary>
        /// 从给定的图像中获取条码
        /// </summary>
        /// <param name="bmp"></param>
        /// <returns></returns>
        public List<BarcodeInfo> GetBarCode(Bitmap bmp)
        {
            List<BarcodeInfo> info = identify.GetCode(bmp);
            return info;
        }



        /*
        /// <summary>
        /// 特征原始图
        /// </summary>
        public void FeatureOriginal()
        {
            for (int i = 0; i < cameraAll.Length; i++)  //所有种类的相机
            {
                if (cameraAll[i].GrabOne(out Bitmap[] bmp))  //一种相机的所有相机照片
                {
                    for (int j = 0; j < bmp.Length; j++)  //单个图像
                    {
                        if (regionLists.TryGetValue(cameraAll[i].Name[j], out List<RegionPlan> plan))
                        {
                            for (int k = 0; k < plan.Count; k++)
                                plan[k].feature.OriginalImage(bmp[j]);
                        }
                    }
                }
            }






                //for (int j = 0; j < cameraAll[i].Count; j++)
                //{
                //    //idx++;
                    
                //    rtn = feature[idx].OriginalImage(bmp);
                //    if (rtn)
                //    {
                //        typeIdx = rtn ? i : -1;
                //        cameraIdx = rtn ? j : -1;
                //        featureIdx = idx;
                //        break;
                //    }
                //}
                //if (rtn) break;
            //}
            //return rtn;
        }

        /// <summary>
        /// 特征原始图
        /// </summary>
        /// <param name="cameraName"></param>
        /// <returns></returns>
        public bool FeatureOriginal(string cameraName)
        {
            bool rtn = false;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                rtn = cameraAll[i].GrabOne(cameraName, out Bitmap bmp);
                if (!rtn) continue;
                rtn = regionLists.ContainsKey(cameraName);
                if (!rtn) continue;
                for (int k = 0; k < regionLists[cameraName].Count; k++)
                    regionLists[cameraName][k].feature.OriginalImage(bmp);


                //int index = feature.FindIndex(match => match.CameraName == cameraName);
                //if (index == -1) return false;
                //rtn = feature[index].OriginalImage(bmp);
                //return rtn;

            }
            return rtn;
        }

        /// <summary>
        /// 特征原始图
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="planName"></param>
        /// <returns></returns>
        public bool FeatureOriginal(string cameraName, string planName)
        {
            bool rtn = false;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                rtn = cameraAll[i].GrabOne(cameraName, out Bitmap bmp);
                if (!rtn) continue;
                rtn = regionLists.ContainsKey(cameraName);
                if (!rtn) continue;
                int index = regionLists[cameraName].FindIndex(match => match.Name == planName);
                if (index == -1)
                    rtn = false;
                else
                    regionLists[cameraName][index].feature.OriginalImage(bmp);
            }
            return rtn;
        }

        /// <summary>
        /// 特征原始图
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="name"></param>
        /// <param name="planName"></param>
        /// <returns></returns>
        public bool FeatureOriginal(Bitmap bmp, string name, string planName)
        {
            bool rtn = regionLists.ContainsKey(name);
            if (rtn)
            {
                int index = regionLists[name].FindIndex(match => match.Name == planName);
                if (index == -1)
                    rtn = false;
                else
                    regionLists[name][index].feature.OriginalImage(bmp);
            }
            return rtn;
        }

        /// <summary>
        /// 特征比较图
        /// </summary>
        /// <param name="exist"></param>
        public void FeatureCompare(out Dictionary<string, Dictionary<string, Dictionary<string, bool>>> exist)
        {
            exist = new();
            for (int i = 0; i < cameraAll.Length; i++)  //所有种类的相机
            {
                if (cameraAll[i].GrabOne(out Bitmap[] bmp))  //一种相机的所有相机照片
                {
                    for (int j = 0; j < bmp.Length; j++)  //单个图像
                    {
                        if (regionLists.TryGetValue(cameraAll[i].Name[j], out List<RegionPlan> planValue))
                        {
                            Dictionary<string, Dictionary<string, bool>> plan = new();
                            for (int k = 0; k < planValue.Count; k++)
                            {
                                if (planValue[k].feature.CompareImage(bmp[j], out Dictionary<string, bool> existValue))
                                {
                                    plan.Add(planValue[k].Name, existValue);
                                }
                            }
                            exist.Add(cameraAll[i].Name[j], plan);
                        }
                        bmp[j].Dispose();
                    }
                }
            }

            //if (typeIdx == -1 || cameraIdx == -1) return false;
            //bool rtn = cameraAll[typeIdx].GrabOne(cameraIdx, out Bitmap bmp);
            //if (rtn) rtn = feature[featureIdx].CompareImage(bmp, out exist);
            //return rtn;
        }

        /// <summary>
        /// 特征比较图
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="exist"></param>
        /// <returns></returns>
        public bool FeatureCompare(string cameraName, out Dictionary<string, Dictionary<string, bool>> exist)
        {
            exist = new();
            bool rtn = false;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                rtn = cameraAll[i].GrabOne(cameraName, out Bitmap bmp);
                if (!rtn) continue;
                rtn = regionLists.ContainsKey(cameraName);
                if (!rtn) continue;
                for (int k = 0; k < regionLists[cameraName].Count; k++)
                {
                    if (regionLists[cameraName][k].feature.CompareImage(bmp, out Dictionary<string, bool> existValue))
                        exist.Add(cameraName, existValue);
                    else
                        rtn = false;
                }
                bmp.Dispose();
            }
            return rtn;
        }

        /// <summary>
        /// 特征比较图
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="planName"></param>
        /// <param name="exist"></param>
        /// <returns></returns>
        public bool FeatureCompare(string cameraName, string planName, out Dictionary<string, bool> exist)
        {
            exist = new();
            bool rtn = false;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                rtn = cameraAll[i].GrabOne(cameraName, out Bitmap bmp);
                if (!rtn) continue;
                rtn = regionLists.ContainsKey(cameraName);
                if (!rtn) continue;
                int index = regionLists[cameraName].FindIndex(match => match.Name == planName);
                if (index == -1)
                    rtn = false;
                else
                    regionLists[cameraName][index].feature.CompareImage(bmp, out exist);
                bmp.Dispose();
            }
            return rtn;
        }

        /// <summary>
        /// 特征比较图
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="cameraName"></param>
        /// <param name="planName"></param>
        /// <param name="exist"></param>
        /// <returns></returns>
        public bool FeatureCompare(Bitmap bmp, string cameraName, string planName, out Dictionary<string, bool> exist)
        {
            exist = new();
            bool rtn = regionLists.ContainsKey(cameraName);
            if (rtn)
            {
                int index = regionLists[cameraName].FindIndex(match => match.Name == planName);
                if (index == -1)
                    rtn = false;
                else
                    regionLists[cameraName][index].feature.CompareImage(bmp, out exist);
            }
            return rtn;
        }
        */


        /// <summary>
        /// 特征单张比较图，没有原图
        /// </summary>
        /// <param name="cameraName"></param>
        /// <param name="planName"></param>
        /// <param name="exist"></param>
        /// <param name="image"></param>
        /// <returns></returns>
        public bool FeatureSingleCompare(string cameraName, string planName, out Dictionary<string, bool> exist, out Bitmap image)
        {
            exist = new();
            image = null;
            bool rtn = false;

            for (int i = 0; i < cameraAll.Length; i++)
            {
                rtn = cameraAll[i].GrabOne(cameraName, out image);
                if (!rtn) continue;
                rtn = regionLists.ContainsKey(cameraName);
                if (!rtn) continue;
                int index = regionLists[cameraName].FindIndex(match => match.Name == planName);
                if (index == -1)
                    rtn = false;
                else
                    rtn = regionLists[cameraName][index].feature.CompareSingleImage(image, out exist);
            }
            return rtn;
        }

        /// <summary>
        /// 特征单张比较图，没有原图
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="cameraName"></param>
        /// <param name="planName"></param>
        /// <param name="exist"></param>
        /// <returns></returns>
        public bool FeatureSingleCompare(Bitmap bmp, string cameraName, string planName, out Dictionary<string, bool> exist)
        {
            exist = new();
            bool rtn = regionLists.ContainsKey(cameraName);
            if (rtn)
            {
                int index = regionLists[cameraName].FindIndex(match => match.Name == planName);
                if (index == -1)
                    rtn = false;
                else
                    rtn = regionLists[cameraName][index].feature.CompareSingleImage(bmp, out exist);
                bmp.Dispose();
            }
            return rtn;
        }





    }
}