using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using MvCamCtrl.NET;
using CameraVisionLib.Model;

namespace Asa.HIK
{
    /// <summary>
    /// 机器视觉面阵相机
    /// </summary>
    internal class VisionCamera : ICamera
    {
        private MyCamera.MV_CC_DEVICE_INFO_LIST cameraAll;
        private MyCamera[] cameraCurr;
        private List<string> cameraName;
        private int result;

        private byte[] _buffer = null;
        private Bitmap _image = null;
        private IntPtr _handle = IntPtr.Zero;
        private PixelFormat _format = PixelFormat.Format24bppRgb;

        /// <summary>
        /// 机器视觉面阵相机
        /// </summary>
        public VisionCamera()
        {
            cameraName = new List<string>();
        }

        /// <summary>
        /// 相机名称
        /// </summary>
        public string[] Name { get => cameraName.ToArray(); }

        /// <summary>
        /// 相机总数
        /// </summary>
        public int Count { get => cameraName.Count; }

        /// <summary>
        /// 相机是否打开
        /// </summary>
        public bool[] IsOpen { private set; get; }

        /// <summary>
        /// 图像分辨率
        /// </summary>
        public Size[] Size { private set; get; }

        /// <summary>
        /// 相机获取到的图像
        /// </summary>
        public Bitmap Image { private set; get; }





        /// <summary>
        /// 加载
        /// </summary>
        /// <returns></returns>
        public bool Load()
        {
            try
            {
                //获取所有相机
                cameraAll = new MyCamera.MV_CC_DEVICE_INFO_LIST();
                result = MyCamera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref cameraAll);
                if (result != MyCamera.MV_OK)
                {
                    Common.log.Info("MV_CC_EnumDevices_NET failed," + result);
                    return false;
                }

                //相机名称
                cameraName.Clear();
                for (int i = 0; i < cameraAll.nDeviceNum; i++)
                {
                    MyCamera.MV_CC_DEVICE_INFO device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(cameraAll.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));
                    if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
                    {
                        IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
                        MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
                        cameraName.Add(string.Format("GigE:{0}({1})", gigeInfo.chModelName, gigeInfo.chSerialNumber));
                    }
                    else if (device.nTLayerType == MyCamera.MV_USB_DEVICE)
                    {
                        IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stUsb3VInfo, 0);
                        MyCamera.MV_USB3_DEVICE_INFO usbInfo = (MyCamera.MV_USB3_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_USB3_DEVICE_INFO));
                        cameraName.Add(string.Format("USB:{0}({1})", usbInfo.chModelName, usbInfo.chSerialNumber));
                    }
                }

                IsOpen = new bool[cameraName.Count];
                Size = new Size[cameraName.Count];
                cameraCurr = new MyCamera[cameraName.Count];
                Common.log.Info("Load OK");
                return true;
            }
            catch (Exception ex)
            {
                Common.log.Error("Load", ex);
                return false;
            }
        }

        /// <summary>
        /// 释放所有
        /// </summary>
        public void Dispose()
        {
            CloseAll();
        }

        /// <summary>
        /// 打开所有相机
        /// </summary>
        /// <returns></returns>
        public bool OpenAll()
        {
            bool rtn = false;
            for (int i = 0; i < cameraName.Count; i++)
            {
                rtn = OpenDevice(i);
                if (!rtn) break;
            }
            return rtn;
        }

        /// <summary>
        /// 关闭所有相机
        /// </summary>
        public void CloseAll()
        {
            for (int i = 0; i < cameraName.Count; i++)
                CloseDevice(i);
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="cameraIndex"></param>
        /// <returns></returns>
        public bool Open(int cameraIndex)
        {
            if (cameraIndex < 0)
                return false;
            else
                return OpenDevice(cameraIndex);
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="cameraName"></param>
        /// <returns></returns>
        public bool Open(string cameraName)
        {
            int idx = this.cameraName.FindIndex(s => s == cameraName);
            return Open(idx);
        }

        /// <summary>
        /// 关闭相机
        /// </summary>
        /// <param name="cameraIndex"></param>
        public void Close(int cameraIndex)
        {
            CloseDevice(cameraIndex);
        }

        /// <summary>
        /// 关闭相机
        /// </summary>
        /// <param name="cameraName"></param>
        public void Close(string cameraName)
        {
            int idx = this.cameraName.FindIndex(s => s == cameraName);
            CloseDevice(idx);
        }

        /// <summary>
        /// 抓取所有相机一张图像
        /// </summary>
        /// <param name="bmp"></param>
        public void GrabOne(out Bitmap[] bmp)
        {
            bmp = new Bitmap[cameraCurr.Length];
            for (int i = 0; i < cameraCurr.Length; i++)
                GrabDevice(i, out bmp[i]);
        }

        /// <summary>
        /// 抓取一张图像
        /// </summary>
        /// <param name="cameraIndex">相机索引</param>
        /// <returns></returns>
        public bool GrabOne(int cameraIndex)
        {
            bool rtn = GrabDevice(cameraIndex, out Bitmap bmp);
            Image = bmp;
            return rtn;
        }

        /// <summary>
        /// 抓取一张图像
        /// </summary>
        /// <param name="cameraIndex">相机索引</param>
        /// <param name="bmp">Bitmap图像</param>
        /// <returns></returns>
        public bool GrabOne(int cameraIndex, out Bitmap bmp)
        {
            return GrabDevice(cameraIndex, out bmp);
        }

        /// <summary>
        /// 抓取一张图像
        /// </summary>
        /// <param name="cameraName">相机名称</param>
        /// <param name="bmp">Bitmap图像</param>
        /// <returns></returns>
        public bool GrabOne(string cameraName, out Bitmap bmp)
        {
            bmp = null;
            int index = this.cameraName.FindIndex(match => match.Contains(cameraName));
            if (index == -1) return false;
            return GrabDevice(index, out bmp);
        }

        /// <summary>
        /// 抓取一张图像字节
        /// </summary>
        /// <param name="cameraIndex">相机索引</param>
        /// <param name="buff">图像字节数组</param>
        /// <param name="format"></param>
        /// <returns></returns>
        public bool GrabOne(int cameraIndex, out byte[] buff, out PixelFormat format)
        {
            return GrabDevice(cameraIndex, out buff, out format);
        }

        /// <summary>
        /// 抓取一张图像指针
        /// </summary>
        /// <param name="cameraIndex"></param>
        /// <param name="handle"></param>
        /// <param name="format"></param>
        /// <returns></returns>
        public bool GrabOne(int cameraIndex, out IntPtr handle, out PixelFormat format)
        {
            return GrabDevice(cameraIndex, out handle, out format);
        }

        //public void PreviewImage(int cameraIndex, IntPtr handle)
        //{
        //}

        public bool PreviewImage(string cameraName, IntPtr handle)
        {
            return false;
        }




        private bool OpenDevice(int idx)
        {
            try
            {
                if (cameraCurr[idx] != null)
                    CloseDevice(idx);

                //创建设备
                cameraCurr[idx] = new MyCamera();
                MyCamera.MV_CC_DEVICE_INFO device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(cameraAll.pDeviceInfo[idx], typeof(MyCamera.MV_CC_DEVICE_INFO));
                result = cameraCurr[idx].MV_CC_CreateDevice_NET(ref device);
                if (result != MyCamera.MV_OK)
                {
                    Common.log.Info(string.Format("{0} MV_CC_CreateDevice_NET failed,{1}", cameraName[idx], result));
                    return false;
                }

                //打开设备
                result = cameraCurr[idx].MV_CC_OpenDevice_NET();
                if (result != MyCamera.MV_OK)
                {
                    Common.log.Info(string.Format("{0} MV_CC_OpenDevice_NET failed,{1}", cameraName[idx], result));
                    cameraCurr[idx].MV_CC_DestroyDevice_NET();
                    return false;
                }

                if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
                {
                    int nPacketSize = cameraCurr[idx].MV_CC_GetOptimalPacketSize_NET();
                    if (nPacketSize > 0)
                        result = cameraCurr[idx].MV_CC_SetIntValue_NET("GevSCPSPacketSize", (uint)nPacketSize);
                }
                //cameraCurr[idx].MV_CC_SetEnumValue_NET("AcquisitionMode", 2);  //工作在连续模式
                cameraCurr[idx].MV_CC_SetEnumValue_NET("TriggerMode", 0);  //连续模式
                MyCamera.MVCC_INTVALUE pstValue = new();
                result = cameraCurr[idx].MV_CC_GetWidth_NET(ref pstValue);
                int w = (int)pstValue.nCurValue;
                result = cameraCurr[idx].MV_CC_GetHeight_NET(ref pstValue);
                int h = (int)pstValue.nCurValue;
                Size[idx] = new Size(w, h);

                result = cameraCurr[idx].MV_CC_StartGrabbing_NET();
                if (result != MyCamera.MV_OK)
                {
                    Common.log.Info(string.Format("{0} MV_CC_StartGrabbing_NET failed,{1}", cameraName[idx], result));
                    return false;
                }

                IsOpen[idx] = true;
                Common.log.Info(string.Format("{0} OpenDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                Common.log.Error("OpenDevice", ex);
                return false;
            }
        }

        private void CloseDevice(int idx)
        {
            if (cameraCurr[idx] == null) return;
            IsOpen[idx] = false;
            cameraCurr[idx].MV_CC_StopGrabbing_NET();
            cameraCurr[idx].MV_CC_CloseDevice_NET();
            cameraCurr[idx].MV_CC_DestroyDevice_NET();
            cameraCurr[idx] = null;
            Common.log.Info("Close OK " + cameraName[idx]);
        }

        private bool GrabDevice(int idx, out Bitmap bmp)
        {
            bmp = null;

            try
            {
                ImageCapture(idx);
                bmp = new(_image);
                Common.log.Info(string.Format("{0} GrabDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                Common.log.Error("GrabDevice", ex);
                return false;
            }
        }

        private bool GrabDevice(int idx, out byte[] buff, out PixelFormat format)
        {
            buff = null;
            format = PixelFormat.Undefined;

            try
            {
                ImageCapture(idx);
                buff = _buffer;
                format = _format;
                Common.log.Info(string.Format("{0} GrabDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                Common.log.Error("GrabDevice", ex);
                return false;
            }
        }

        private bool GrabDevice(int idx, out IntPtr handle, out PixelFormat format)
        {
            handle = IntPtr.Zero;
            format = PixelFormat.Undefined;

            try
            {
                ImageCapture(idx);
                handle = _handle;
                format = _format;
                Common.log.Info(string.Format("{0} GrabDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                Common.log.Error("GrabDevice", ex);
                return false;
            }
        }

        private void ImageCapture(int idx)
        {
            MyCamera.MVCC_INTVALUE stParam = new();
            result = cameraCurr[idx].MV_CC_GetIntValue_NET("PayloadSize", ref stParam);
            if (result != MyCamera.MV_OK)
            {
                Common.log.Info(string.Format("{0} MV_CC_GetIntValue_NET failed,{1}", cameraName[idx], result));
                return;
            }

            uint dataSize = stParam.nCurValue;
            byte[] dataArr = new byte[dataSize];
            uint buffSize = dataSize * 3 + 2048;
            byte[] buffArr = new byte[buffSize];
            IntPtr pData = Marshal.UnsafeAddrOfPinnedArrayElement(dataArr, 0);
            MyCamera.MV_FRAME_OUT_INFO_EX stFrameInfo = new();
            result = cameraCurr[idx].MV_CC_GetOneFrameTimeout_NET(pData, dataSize, ref stFrameInfo, 100000);
            if (result != MyCamera.MV_OK)
            {
                Common.log.Info(string.Format("{0} MV_CC_GetOneFrameTimeout_NET failed,{1}", cameraName[idx], result));
                return;
            }

            MyCamera.MvGvspPixelType enDstPixelType = stFrameInfo.enPixelType;
            switch (stFrameInfo.enPixelType)
            {
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12_Packed:
                    enDstPixelType = stFrameInfo.enPixelType; break;
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_YUV422_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_YUV422_YUYV_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_YCBCR411_8_CBYYCRYY:
                    enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed; break;
            }

            IntPtr pImage = Marshal.UnsafeAddrOfPinnedArrayElement(buffArr, 0);
            MyCamera.MV_PIXEL_CONVERT_PARAM stConverPixelParam = new()
            {
                nWidth = stFrameInfo.nWidth,
                nHeight = stFrameInfo.nHeight,
                pSrcData = pData,
                nSrcDataLen = stFrameInfo.nFrameLen,
                enSrcPixelType = stFrameInfo.enPixelType,
                enDstPixelType = enDstPixelType,
                pDstBuffer = pImage,
                nDstBufferSize = buffSize
            };
            result = cameraCurr[idx].MV_CC_ConvertPixelType_NET(ref stConverPixelParam);
            if (result != MyCamera.MV_OK)
            {
                Common.log.Info(string.Format("{0} MV_CC_ConvertPixelType_NET failed,{1}", cameraName[idx], result));
                return;
            }
           

            if (enDstPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
            {
                _image = new Bitmap(stFrameInfo.nWidth, stFrameInfo.nHeight, stFrameInfo.nWidth * 1, PixelFormat.Format8bppIndexed, pImage);
                _format = PixelFormat.Format8bppIndexed;
                _handle = pImage;

                ColorPalette cp = _image.Palette;
                for (int i = 0; i < 256; i++)
                    cp.Entries[i] = Color.FromArgb(i, i, i);
                _image.Palette = cp;

                int picSize = _image.Width * _image.Height;
                _buffer = new byte[picSize];
                Array.Copy(buffArr, _buffer, picSize);


                //Rectangle rect = new Rectangle(0, 0, Image.Width, Image.Height);
                //BitmapData bmpData = Image.LockBits(rect, ImageLockMode.ReadWrite, Image.PixelFormat);
                //IntPtr iPtr = bmpData.Scan0;
                //int picSize = Image.Width * Image.Height;
                //Buffer = new byte[picSize];
                //Marshal.Copy(iPtr, Buffer, 0, picSize);
                //Image.UnlockBits(bmpData);
            }
            else
            {
                for (int i = 0; i < stFrameInfo.nHeight; i++)
                {
                    for (int j = 0; j < stFrameInfo.nWidth; j++)
                    {
                        byte chRed = buffArr[i * stFrameInfo.nWidth * 3 + j * 3];
                        buffArr[i * stFrameInfo.nWidth * 3 + j * 3] = buffArr[i * stFrameInfo.nWidth * 3 + j * 3 + 2];
                        buffArr[i * stFrameInfo.nWidth * 3 + j * 3 + 2] = chRed;
                    }
                }
                _image = new Bitmap(stFrameInfo.nWidth, stFrameInfo.nHeight, stFrameInfo.nWidth * 3, PixelFormat.Format24bppRgb, pImage);
                _format = PixelFormat.Format24bppRgb;
                _handle = pImage;

                int picSize = _image.Width * _image.Height * 3;
                _buffer = new byte[picSize];
                Array.Copy(buffArr, _buffer, picSize);
            }
        }


    }
}