using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace TH.Parking.Wrapper.HBCamera
{
    public class CameraUtilities
    {
        public static bool AllowRecordVideo { get; set; }
        private T1800.STREAM_READ_CALLBACK m_del;
        private IntPtr m_tmpContext;
        private GCHandle m_handle;
        private HB18TCamera[] m_ListCameras;
        Mutex m_Mutext = new Mutex();
        public HB18TCamera[] ListCameras
        {
            get { return m_ListCameras; }
            set { m_ListCameras = value; }
        }
        private ulong[] m_callBackChannels;

        public static HB18TCamera[] InitCameras(string rootFolderPath, string videoFolderPath, int maxRecordFileSize)
        {

            T1800.T18_SetDefaultVideoStandard(T1800.VideoStandard.StandardNone);
            int dsps = T1800.T18_InitDSPs();
            int totalDsps = T1800.T18_GetTotalDSPs();
            int totalChannels = T1800.T18_GetTotalChannels();
            HB18TCamera[] lstCamera = new HB18TCamera[totalChannels];
            IntPtr channelHandle = new IntPtr();
            string storeFilePath = string.Empty;
            string storeVideoPath = string.Empty;
            for (int i = 0; i < totalChannels; i++)
            {
                storeFilePath = string.Format("{0}\\{1}", rootFolderPath, (i + 1).ToString());
                storeVideoPath = string.Format("{0}\\{1}", videoFolderPath, (i + 1).ToString());

                if (!Directory.Exists(storeFilePath))
                    Directory.CreateDirectory(storeFilePath);

                if (!Directory.Exists(storeVideoPath))
                    Directory.CreateDirectory(storeVideoPath);

                channelHandle = T1800.T18_ChannelOpen(i);
                lstCamera[i] = new HB18TCamera(channelHandle, storeFilePath, storeVideoPath, maxRecordFileSize);
            }

            return lstCamera;
        }

        public static bool DeInits()
        {
            if (T1800.T18_DeInitDSPs() == -1) return false;
            else return true;
        }

        int cameraCurrentIndex = -1;

        public void StartRecord()
        {
            if (this.ListCameras != null)
            {
                bool bRes = true;
                try
                {
                    int tmpError = -1;
                    m_tmpContext = new IntPtr();
                    m_handle = new GCHandle();
                    m_callBackChannels = new ulong[m_ListCameras.Length];

                    for (int i = 0; i < m_ListCameras.Length; i++)
                    {
                        m_callBackChannels[i] = 10;
                        cameraCurrentIndex = 0;
                        IntPtr channelHandle = T1800.T18_ChannelOpen(cameraCurrentIndex);
                        m_ListCameras[cameraCurrentIndex].ChannelHandle = channelHandle;
                        T1800.T18_CaptureIFrame(m_ListCameras[i].ChannelHandle);



                        m_ListCameras[i].BeginRecord();
                        if (AllowRecordVideo)
                        {
                            m_del = new T1800.STREAM_READ_CALLBACK(StreamReadCallBack);
                            m_tmpContext = m_ListCameras[i].ChannelHandle;
                            tmpError = T1800.T18_RegisterStreamReadCallback(m_del, ref m_tmpContext);
                        }
                    }




                    if (tmpError == -1) bRes = false;
                }
                catch (Exception ex)
                {
                    Log.Logger.Error(ex);
                    bRes = false;
                }
            }
        }

        private void OpenAndRecordChanel()
        {
            IntPtr channelHandle = T1800.T18_ChannelOpen(cameraCurrentIndex);
            m_ListCameras[cameraCurrentIndex].ChannelHandle = channelHandle;
            T1800.T18_CaptureIFrame(channelHandle);
            m_ListCameras[cameraCurrentIndex].BeginRecord();
            int error = T1800.T18_SetLogoDisplayMode(channelHandle, T1800.ToUlong(255, 255, 255), true, 0);
            if (error == 0)
            {
                int length = 200 * 200 * 4;
                IntPtr imgBuff = new IntPtr(length);
                int w, h;
                w = h = 96;

                IntPtr orgBuff = new IntPtr(704 * 576 * 2);
                ulong size = (704 * 576 * 2);
                int tmp = T1800.T18_GetOriginalImage(channelHandle, orgBuff, ref size, 1);
                if (tmp == 0)
                {
                    error = T1800.T18_SetLogo(channelHandle, 0, 0, 96, 96, orgBuff);
                }

                //error = T1800.T18_LoadYUV444FromBmpFile("logo.bmp", ref imgBuff, length, ref w, ref h);
                if (error == 0)
                {
                    error = T1800.T18_SetLogo(channelHandle, 0, 0, 96, 96, imgBuff);
                }
            }
        }

        private void AssignCallBackChannel(ulong channelHandle)
        {
            for (int i = 0; i < m_callBackChannels.Length; i++)
            {
                if (m_callBackChannels[i] == 10)
                {
                    m_callBackChannels[i] = channelHandle;
                    break;
                }
            }
        }

        private int GetCallBackIndex(ulong channelHandle)
        {
            int tmp = 0;
            for (int i = 0; i < m_callBackChannels.Length; i++)
            {
                tmp = i;
                if (m_callBackChannels[i] == channelHandle) break;
            }
            return tmp;
        }

        private int ImageStreamReadCallBack(ulong channelHandle, IntPtr context)
        {
            return 0;
        }

        private int StreamReadCallBack(ulong channelHandle, IntPtr context)
        {
            Log.Logger.Error("enter m_del = new T1800.STREAM_READ_CALLBACK(StreamReadCallBack);");
            try
            {

                Application.DoEvents();
                GC.KeepAlive(m_del);
                GC.KeepAlive(m_tmpContext);
                GC.KeepAlive(m_handle);
                GC.KeepAlive(m_callBackChannels);
                GC.KeepAlive(m_Mutext);
                GC.KeepAlive(m_ListCameras);
                if (channelHandle == 0)
                    return 0;
                m_Mutext.WaitOne();
                Application.DoEvents();
                HB18TCamera current = null;
                foreach (var item in m_ListCameras)
                {
                    if (item.CallBackChannelHandle == channelHandle)
                    {
                        current = item;
                        break;
                    }
                }
                if (current != null)
                {
                    current.SaveCallBackData();
                    Log.Logger.Error("SaveCallBackData 1");
                }
                else if (cameraCurrentIndex < m_ListCameras.Length)
                {
                    m_ListCameras[cameraCurrentIndex].CallBackChannelHandle = channelHandle;
                    m_ListCameras[cameraCurrentIndex].SaveCallBackData();
                    Log.Logger.Error("SaveCallBackData 2");

                    cameraCurrentIndex++;
                    if (cameraCurrentIndex < m_ListCameras.Length)
                    {
                        m_ListCameras[cameraCurrentIndex].ChannelHandle = T1800.T18_ChannelOpen(cameraCurrentIndex);
                        T1800.T18_CaptureIFrame(m_ListCameras[cameraCurrentIndex].ChannelHandle);
                        m_ListCameras[cameraCurrentIndex].BeginRecord();
                    }
                }

                if (m_ListCameras[cameraCurrentIndex].CallBackChannelHandle == 0)
                    m_ListCameras[cameraCurrentIndex].CallBackChannelHandle = channelHandle;
                else if (m_ListCameras[cameraCurrentIndex].CallBackChannelHandle == channelHandle)
                {
                    m_ListCameras[GetCallBackIndex(channelHandle)].SaveCallBackData();
                    Log.Logger.Error("SaveCallBackData 3");
                }
                AssignCallBackChannel(channelHandle);
                Application.DoEvents();
                int index = (int)channelHandle;
                if (channelHandle >= (ulong)m_ListCameras.Length)
                {
                    index = (int)(channelHandle / 4294967297);
                }
                if (index > m_ListCameras.Length || m_ListCameras.Length < 0)
                    index = 0;
                m_ListCameras[index].SaveCallBackData();
                Log.Logger.Error("SaveCallBackData 4");
                Application.DoEvents();

                m_Mutext.ReleaseMutex();
            }
            catch (Exception ex)
            {

                Log.Logger.Error(ex);
                //throw;
            }
            return 0;
        }
    }
}