using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using Asa.CameraFactory;
using System.Drawing.Imaging;
using Basler.Pylon;

namespace Asa.Basler
{
    /// <summary>
    /// 机器视觉面阵相机
    /// </summary>
    public class VisionCamera : CameraFactory.ICamera
    {
        /// <summary>
        /// 当前相机
        /// </summary>
        private global::Basler.Pylon.Camera[] cameraCurr;
        /// <summary>
        /// 所有相机列表
        /// </summary>
        private List<ICameraInfo> cameraAll;
        /// <summary>
        /// 所有相机的名称
        /// </summary>
        private List<string> cameraName;

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

        /// <summary>
        /// 机器视觉面阵相机
        /// </summary>
        /// <param name="logName"></param>
        public VisionCamera(string logName = "Basler.VisionCamera")
        {
            cameraName = new List<string>();
            if (!string.IsNullOrWhiteSpace(logName))
                Log.Load(logName);
        }



        /// <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; }

        IntPtr CameraFactory.ICamera.Preview { set; get; } = IntPtr.Zero;



        /// <summary>
        /// 加载
        /// </summary>
        /// <returns></returns>
        public bool Load()
        {
            try
            {
                cameraAll = CameraFinder.Enumerate();

                //相机名称
                cameraName.Clear();
                foreach (ICameraInfo info in cameraAll)
                    cameraName.Add(string.Format("{0}({1})", info[CameraInfoKey.ModelName], info[CameraInfoKey.SerialNumber]));

                IsOpen = new bool[cameraName.Count];
                Size = new Size[cameraName.Count];
                cameraCurr = new global::Basler.Pylon.Camera[cameraName.Count];
                Log.Info("Load OK");
                return true;
            }
            catch (Exception ex)
            {
                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)
        {
            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="bmp"></param>
        /// <returns></returns>
        public bool GrabOne(out Bitmap[] bmp)
        {
            bmp = new Bitmap[cameraCurr.Length];
            bool rtn = false;
            for (int i = 0; i < cameraCurr.Length; i++)
            {
                rtn = GrabDevice(i, out bmp[i]);
                if (!rtn) break;
            }
            return rtn;
        }

        /// <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);
        }



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

                cameraCurr[idx] = new global::Basler.Pylon.Camera(cameraAll[idx]);
                //cameraCur.ConnectionLost += OnConnectionLost;
                //cameraCur.CameraOpened += OnCameraOpened;
                //cameraCur.CameraClosed += OnCameraClosed;
                //cameraCur.StreamGrabber.GrabStarted += OnGrabStarted;
                //cameraCurr[idx].StreamGrabber.ImageGrabbed += OnImageGrabbed;
                //cameraCur.StreamGrabber.GrabStopped += OnGrabStopped;
                cameraCurr[idx].Open();
                int w = Convert.ToInt32(cameraCurr[idx].Parameters[PLCamera.Width].GetValue());
                int h = Convert.ToInt32(cameraCurr[idx].Parameters[PLCamera.Height].GetValue());
                Size[idx] = new Size(w, h);

                cameraCurr[idx].Parameters[PLCamera.UserSetSelector].SetValue(PLCamera.UserSetSelector.UserSet1);  //加载用户设置1
                bool bln = cameraCurr[idx].Parameters[PLCamera.UserSetLoad].TryExecute();  //执行设置

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

        private void CloseDevice(int idx)
        {
            if (cameraCurr[idx] == null) return;
            IsOpen[idx] = false;
            cameraCurr[idx].Close();
            cameraCurr[idx].Dispose();
            cameraCurr[idx] = null;
            Log.Info("Close OK " + cameraName[idx]);
        }

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

            try
            {
                ImageCapture(idx);
                bmp = new(_image);
                Log.Info(string.Format("{0} GrabDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                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;
                Log.Info(string.Format("{0} GrabDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                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;
                Log.Info(string.Format("{0} GrabDevice OK", cameraName[idx]));
                return true;
            }
            catch (Exception ex)
            {
                Log.Error("GrabDevice", ex);
                return false;
            }
        }

        private void ImageCapture(int idx)
        {
            cameraCurr[idx].Parameters[PLCamera.AcquisitionMode].SetValue(PLCamera.AcquisitionMode.SingleFrame);
            IGrabResult grabResult = cameraCurr[idx].StreamGrabber.GrabOne(5000);
            if (!grabResult.IsValid)
            {
                Log.Info(string.Format("{0} GrabOne failed,{1}", cameraName[idx], grabResult.ErrorCode));
                return;
            }

            _image = new Bitmap(grabResult.Width, grabResult.Height, PixelFormat.Format24bppRgb);
            BitmapData bmpData = _image.LockBits(new Rectangle(0, 0, grabResult.Width, grabResult.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            IntPtr ptrBmp = bmpData.Scan0;
            int picSize = bmpData.Stride * grabResult.Height;
            PixelDataConverter conv = new() { OutputPixelFormat = PixelType.BGR8packed };
            conv.Convert(ptrBmp, picSize, grabResult);
            _buffer = new byte[picSize];
            System.Runtime.InteropServices.Marshal.Copy(ptrBmp, _buffer, 0, picSize);
            _image.UnlockBits(bmpData);
            _handle = ptrBmp;
            _format = PixelFormat.Format24bppRgb;
        }











        //private void OnImageGrabbed(object sender, ImageGrabbedEventArgs e)
        //{
        //    try
        //    {
        //        IGrabResult grabResult = e.GrabResult;
        //        if (!grabResult.IsValid) return;

        //        _image = new Bitmap(grabResult.Width, grabResult.Height, PixelFormat.Format24bppRgb);
        //        BitmapData bmpData = _image.LockBits(new Rectangle(0, 0, grabResult.Width, grabResult.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
        //        IntPtr ptrBmp = bmpData.Scan0;
        //        int picSize = bmpData.Stride * grabResult.Height;

        //        PixelDataConverter conv = new PixelDataConverter();
        //        conv.OutputPixelFormat = PixelType.BGR8packed;
        //        conv.Convert(ptrBmp, picSize, grabResult);
        //        _buffer = new byte[picSize];
        //        System.Runtime.InteropServices.Marshal.Copy(ptrBmp, _buffer, 0, picSize);

        //        _format = PixelFormat.Format24bppRgb;
        //        _handle = ptrBmp;
        //        _image.UnlockBits(bmpData);

        //        Continuous_Event?.Invoke();
        //    }
        //    catch (Exception ex)
        //    {
        //        _errInfo = ex.Message;
        //    }
        //    finally
        //    {
        //        e.DisposeGrabResultIfClone();
        //    }
        //}

    }
}