using log4net;
using log4net.Config;
using OnlineStore.Common;
using OnlineStore.XLRStore;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using System.Windows.Forms;
using OnlineStore.DeviceLibrary;
using System.Runtime.ExceptionServices;
using System.ComponentModel;
using System.IO;

namespace OnlineStore.XLRStore
{
    static class Program
    {
        #region 方法四：使用的Win32函数的声明

        /// <summary>
        /// 找到某个窗口与给出的类别名和窗口名相同窗口 
        /// </summary>
        /// <param name="lpClassName">类别名</param>
        /// <param name="lpWindowName">窗口名</param>
        /// <returns>成功找到返回窗口句柄,否则返回null</returns>
        [DllImport("user32.dll")]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        /// <summary>
        /// 切换到窗口并把窗口设入前台,类似 SetForegroundWindow方法的功能
        /// </summary>
        /// <param name="hWnd">窗口句柄</param>
        /// <param name="fAltTab">True代表窗口正在通过Alt/Ctrl +Tab被切换</param>
        [DllImport("user32.dll ", SetLastError = true)]
        static extern void SwitchToThisWindow(IntPtr hWnd, bool fAltTab);

        /// <summary>
        ///  设置窗口的显示状态 
        /// </summary>
        /// <param name="hWnd">窗口句柄</param>
        /// <param name="cmdShow">指示窗口如何被显示</param>
        /// <returns>如果窗体之前是可见，返回值为非零；如果窗体之前被隐藏，返回值为零</returns>
        [DllImport("user32.dll", EntryPoint = "ShowWindow", CharSet = CharSet.Auto)]
        public static extern int ShowWindow(IntPtr hwnd, int nCmdShow);
        public const int SW_RESTORE = 9;
        public static IntPtr formhwnd;
        //public static readonly ILog LOGGER = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        #endregion

        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        [HandleProcessCorruptedStateExceptions]
        static void Main(string[] Args)
        {
            Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
            AppDomain.CurrentDomain.FirstChanceException += CurrentDomain_FirstChanceException;
            // 因为方法三只能是最小化的窗体显示出来，如果隐藏到托盘中则不能把运行的程序显示出来 
            Process currentproc = Process.GetCurrentProcess();
            Process[] processcollection = Process.GetProcessesByName(currentproc.ProcessName.Replace(".vshost", string.Empty));
            //  该程序已经运行，

            bool isShow = false;
            if (processcollection.Length >= 1)
            {
                foreach (Process process in processcollection)
                {
                    if (process.Id != currentproc.Id)
                    {
                        // 如果进程的句柄为0，即代表没有找到该窗体，即该窗体隐藏的情况时
                        if (process.MainWindowHandle.ToInt32().Equals(0))
                        {
                            string formTitle = ConfigAppSettings.GetValue(Setting_Init.App_Title);
                            // 获得窗体句柄
                            formhwnd = FindWindow(null, formTitle);
                            // 重新显示该窗体并切换到带入到前台
                            ShowWindow(formhwnd, SW_RESTORE);
                            SwitchToThisWindow(formhwnd, true);
                            isShow = true;
                            break;
                        }
                        else
                        {
                            // 如果窗体没有隐藏，就直接切换到该窗体并带入到前台
                            // 因为窗体除了隐藏到托盘，还可以最小化
                            SwitchToThisWindow(process.MainWindowHandle, true);
                            isShow = true;
                            break;
                        }
                    }
                }
            }
            if (!isShow)
            {
                System.Net.ServicePointManager.DefaultConnectionLimit = 512;
                XmlConfigurator.Configure();
                // deleteFiles(Application.StartupPath + @"\test\");
                //deleteFiles(Application.StartupPath + @"\test1\");
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                ManagerUtil.Init();
                Application.Run(new FrmXLRStore());
            }
        }
        static void deleteFiles(string dire)
        {
            int CntImgs = 2;

            try
            {
                string[] imgFiles = Directory.GetFiles(dire);
                if (imgFiles.Length <= CntImgs)
                {
                    return;
                }
                FileInfo fileInfo;
                List<FileInfo> files = new List<FileInfo>();
                foreach (var item in imgFiles)
                {
                    fileInfo = new FileInfo(item);
                    files.Add(fileInfo);
                }
                do
                {
                    FileInfo oldFile = files[0];
                    foreach (var item in files)
                    {
                        if ((item.CreationTime - oldFile.CreationTime).TotalSeconds < 0)
                        {
                            oldFile = item;
                        }
                    }
                    oldFile?.Delete();
                    files.Remove(oldFile);
                }
                while (files.Count > CntImgs);

            }
            catch (Exception ex)
            {
                LogUtil.error("删除文件失败", ex);
            }

        }
        private static void CurrentDomain_FirstChanceException(object sender, System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e)
        {
            // LogUnhandledException("CurrentDomain_FirstChanceException", e.Exception.StackTrace);
        }

        static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            LogUnhandledException("CurrentDomain_UnhandledException", e.ToString() + " | " + e.ExceptionObject.ToString() + " ");
        }

        static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
        {
            LogUnhandledException("Application_ThreadException", e.ToString() + " | " + e.Exception.ToString() + " ");
        }

        static void LogUnhandledException(string type, string exceptionobj)
        {
            //这里可以进一步地写日志
            LogUtil.error("【" + type + "】" + exceptionobj);
            MiniDump.Write(Application.StartupPath + "\\ErrorDump\\" + DateTime.Now.ToString("yyyyMMddHHmmss") + "-XLR-error.dmp");
            MessageBox.Show(exceptionobj, type);
        }

        #region dump
        public sealed class MiniDump
        {
            [Flags]
            public enum DumpType : uint
            {
                // From dbghelp.h:
                MiniDumpNormal = 0x00000000,
                MiniDumpWithDataSegs = 0x00000001,
                MiniDumpWithFullMemory = 0x00000002,
                MiniDumpWithHandleData = 0x00000004,
                MiniDumpFilterMemory = 0x00000008,
                MiniDumpScanMemory = 0x00000010,
                MiniDumpWithUnloadedModules = 0x00000020,
                MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
                MiniDumpFilterModulePaths = 0x00000080,
                MiniDumpWithProcessThreadData = 0x00000100,
                MiniDumpWithPrivateReadWriteMemory = 0x00000200,
                MiniDumpWithoutOptionalData = 0x00000400,
                MiniDumpWithFullMemoryInfo = 0x00000800,
                MiniDumpWithThreadInfo = 0x00001000,
                MiniDumpWithCodeSegs = 0x00002000,
                MiniDumpWithoutAuxiliaryState = 0x00004000,
                MiniDumpWithFullAuxiliaryState = 0x00008000,
                MiniDumpWithPrivateWriteCopyMemory = 0x00010000,
                MiniDumpIgnoreInaccessibleMemory = 0x00020000,
                MiniDumpValidTypeFlags = 0x0003ffff,
            };

            //typedef struct _MINIDUMP_EXCEPTION_INFORMATION {
            //    DWORD ThreadId;
            //    PEXCEPTION_POINTERS ExceptionPointers;
            //    BOOL ClientPointers;
            //} MINIDUMP_EXCEPTION_INFORMATION, *PMINIDUMP_EXCEPTION_INFORMATION;
            [StructLayout(LayoutKind.Sequential, Pack = 4)]  // Pack=4 is important! So it works also for x64!
            struct MiniDumpExceptionInformation
            {
                public uint ThreadId;
                public IntPtr ExceptioonPointers;
                [MarshalAs(UnmanagedType.Bool)]
                public bool ClientPointers;
            }

            //BOOL
            //WINAPI
            //MiniDumpWriteDump(
            //    __in HANDLE hProcess,
            //    __in DWORD ProcessId,
            //    __in HANDLE hFile,
            //    __in MINIDUMP_TYPE DumpType,
            //    __in_opt PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
            //    __in_opt PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
            //    __in_opt PMINIDUMP_CALLBACK_INFORMATION CallbackParam
            //    );
            [DllImport("dbghelp.dll",
              EntryPoint = "MiniDumpWriteDump",
              CallingConvention = CallingConvention.StdCall,
              CharSet = CharSet.Unicode,
              ExactSpelling = true, SetLastError = true)]
            static extern bool MiniDumpWriteDump(
              IntPtr hProcess,
              uint processId,
              IntPtr hFile,
              uint dumpType,
              ref MiniDumpExceptionInformation expParam,
              IntPtr userStreamParam,
              IntPtr callbackParam);

            [DllImport("kernel32.dll", EntryPoint = "GetCurrentThreadId", ExactSpelling = true)]
            static extern uint GetCurrentThreadId();

            [DllImport("kernel32.dll", EntryPoint = "GetCurrentProcess", ExactSpelling = true)]
            static extern IntPtr GetCurrentProcess();

            [DllImport("kernel32.dll", EntryPoint = "GetCurrentProcessId", ExactSpelling = true)]
            static extern uint GetCurrentProcessId();

            public static bool Write(string fileName)
            {
                return Write(fileName, DumpType.MiniDumpWithFullMemory);
            }
            public static bool Write(string fileName, DumpType dumpType)
            {           
                using (var fs = new System.IO.FileStream(fileName, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write, System.IO.FileShare.None))
                {
                    MiniDumpExceptionInformation exp;
                    exp.ThreadId = GetCurrentThreadId();
                    exp.ClientPointers = false;
                    exp.ExceptioonPointers = System.Runtime.InteropServices.Marshal.GetExceptionPointers();
                    bool bRet = MiniDumpWriteDump(
                      GetCurrentProcess(),
                      GetCurrentProcessId(),
                      fs.SafeFileHandle.DangerousGetHandle(),
                      (uint)dumpType,
                      ref exp,
                      IntPtr.Zero,
                      IntPtr.Zero);
                    return bRet;
                }
            }
            #endregion
        }
    }
}