using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Windows.Forms;
using System.IO;

namespace WebAAA
{

   public  static class Program
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main()
        {

            try
            {
                //处理未捕获的异常   
                Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
                //处理UI线程异常   
                Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
                //处理非UI线程异常   
                AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
                bool fuckingme;
                Process instance = RunningInstance();
                System.Threading.Mutex webaaa = new System.Threading.Mutex(true, "lemonzdemon", out fuckingme);
                //if (instance == null)
                //{
                if (fuckingme)
                {
                    Application.EnableVisualStyles();
                    Application.SetCompatibleTextRenderingDefault(false);
                    Application.Run(new Form1());
                    webaaa.ReleaseMutex();
                }
                else
                {
                    HandleRunningInstance(instance);
                    //MessageBox.Show("我已经运行啦~~", "主人您好：", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                string str = "";
                string strDateInfo = "出现应用程序未处理的异常：" + DateTime.Now.ToString() + "\r\n";

                if (ex != null)
                {
                    str = string.Format(strDateInfo + "异常类型：{0}\r\n异常消息：{1}\r\n异常信息：{2}\r\n",
                         ex.GetType().Name, ex.Message, ex.StackTrace);
                }
                else
                {
                    str = string.Format("应用程序线程错误:{0}", ex);
                }
                writeLog(str);
                MessageBox.Show("发生程序错误，请把Errlog目录的文件发送给作者！ \n\n Errlog.txt能帮助作者修复程序~\n\n作者邮箱：************@qq.com", "系统错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

       #region  确保程序只运行一个实例
         private static Process RunningInstance()
         {
             Process current = Process.GetCurrentProcess();
             Process[] processes = Process.GetProcessesByName(current.ProcessName);
             //遍历与当前进程名称相同的进程列表  
             foreach (Process process in processes)
             {
                 //如果实例已经存在则忽略当前进程  
                 if (process.Id != current.Id)
                 {
                     //保证要打开的进程同已经存在的进程来自同一文件路径
                    if (Assembly.GetExecutingAssembly().Location.Replace("//", "\\") == current.MainModule.FileName)
                     {
                         //返回已经存在的进程
                         return process;
                         
                     }
                 }
             }
             return null;
         }
 
         private static void HandleRunningInstance(Process instance)
         {
             MessageBox.Show("我已经运行啦~~", "主人您好：", MessageBoxButtons.OK, MessageBoxIcon.Information);
             ShowWindowAsync(instance.MainWindowHandle, 1);  //调用api函数，正常显示窗口
             SetForegroundWindow(instance.MainWindowHandle); //将窗口放置最前端
         }
         [DllImport("User32.dll")]
         private static extern bool ShowWindowAsync(System.IntPtr hWnd, int cmdShow);
         [DllImport("User32.dll")]
         private static extern bool SetForegroundWindow(System.IntPtr hWnd);
         #endregion
             static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
        {
            
            string str = "";
            string strDateInfo = "出现应用程序未处理的异常：" + DateTime.Now.ToString() + "\r\n";
            Exception error = e.Exception as Exception;
            if (error != null)
            {
                str = string.Format(strDateInfo + "异常类型：{0}\r\n异常消息：{1}\r\n异常信息：{2}\r\n",
                     error.GetType().Name, error.Message, error.StackTrace);
            }
            else
            {
                str = string.Format("应用程序线程错误:{0}", e);
            }
            writeLog(str);
            MessageBox.Show("发生程序错误，请把Errlog目录的文件发送给作者！ \n\n Errlog.txt能帮助作者修复程序~\n\n作者邮箱：**********@qq.com", "系统错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            string str = "";
            Exception error = e.ExceptionObject as Exception;
            string strDateInfo = "出现应用程序未处理的异常：" + DateTime.Now.ToString() + "\r\n";
            if (error != null)
            {
                str = string.Format(strDateInfo + "Application UnhandledException:{0};\n\r堆栈信息:{1}", error.Message, error.StackTrace);
            }
            else
            {
                str = string.Format("Application UnhandledError:{0}", e);
            }
            writeLog(str);
            MessageBox.Show("发生程序错误，请把Errlog目录的文件发送给作者！ \n\n Errlog.txt能帮助作者修复程序~\n\n作者邮箱：**********@qq.com", "系统错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
        /// 写文件
        static void writeLog(string str)
        {
            if (!Directory.Exists("ErrLog"))
            {
                Directory.CreateDirectory("ErrLog");
            }

            using (StreamWriter sw = new StreamWriter(@"ErrLog\ErrLog.txt", true))
            {
                sw.WriteLine(str);
                sw.WriteLine("---------------------------------------------------------");
                sw.Close();
            }
        }
    }

}
    

public Form1()
        {
            InitializeComponent();
            AnimateWindow(this.Handle, 800, AW_BLEND + AW_CENTER + AW_ACTIVATE);
            this.MaximizeBox = false; 
            this.AutoSizeMode = AutoSizeMode.GrowAndShrink; // 禁用手动调整大小。
            this.SizeGripStyle = SizeGripStyle.Hide; // 隐藏调整大小手柄。
            this.StartPosition = FormStartPosition.CenterScreen; // 在桌面居中显示。
            webBrowser1.ScriptErrorsSuppressed = true;  //禁用错误脚本提示   
            webBrowser1.IsWebBrowserContextMenuEnabled = false;  //禁用右键菜单   
            webBrowser1.WebBrowserShortcutsEnabled = false;  //禁用快捷键
            webBrowser1.AllowWebBrowserDrop = false; //禁止拖拽
            webBrowser1.ScrollBarsEnabled = false; //禁止滚动条
 
        } 

private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
                AnimateWindow(this.Handle, 800, AW_BLEND + AW_SLIDE + AW_CENTER + AW_HIDE);
                Environment.Exit(Environment.ExitCode);
        }
        private void XFormMain_FormClosed(object sender, FormClosedEventArgs e)
        {
            //动态关闭窗体
            AnimateWindow(this.Handle, 800, AW_SLIDE + AW_HIDE + AW_CENTER);
        }

private string userAgent = "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0)";

        [DllImport("urlmon.dll", CharSet = CharSet.Unicode)]
        private static extern int UrlMkSetSessionOption(int dwOption, string pBuffer, int dwBufferLength, int dwReserved);
        private const int UrlmonOptionUseragent = 0x10000001;

        [DllImportAttribute("user32.dll")]
        private static extern bool AnimateWindow(IntPtr hwnd, int dwTime, int dwFlags);
        /*
        1. AW_SLIDE : 使用滑动类型, 默认为该类型. 当使用 AW_CENTER 效果时, 此效果被忽略
        2. AW_ACTIVE: 激活窗口, 在使用了 AW_HIDE 效果时不可使用此效果
        3. AW_BLEND: 使用淡入效果
        4. AW_HIDE: 隐藏窗口
        5. AW_CENTER: 与 AW_HIDE 效果配合使用则效果为窗口几内重叠,  单独使用窗口向外扩展.
        6. AW_HOR_POSITIVE : 自左向右显示窗口
        7. AW_HOR_NEGATIVE: 自右向左显示窗口
        8. AW_VER_POSITVE: 自顶向下显示窗口
        9. AW_VER_NEGATIVE : 自下向上显示窗口
        */
        public const Int32 AW_HOR_POSITIVE = 0x00000001;
        public const Int32 AW_HOR_NEGATIVE = 0x00000002;
        public const Int32 AW_VER_POSITIVE = 0x00000004;
        public const Int32 AW_VER_NEGATIVE = 0x00000008;
        public const Int32 AW_CENTER = 0x00000010;
        public const Int32 AW_HIDE = 0x00010000;
        public const Int32 AW_ACTIVATE = 0x00020000;
        public const Int32 AW_SLIDE = 0x00040000;
        public const Int32 AW_BLEND = 0x00080000;

   [System.Runtime.InteropServices.DllImport("User32.dll")]
        private static extern bool IsIconic(IntPtr hWnd);
          [DllImport("user32.dll", CharSet = CharSet.Auto)]
       private  static extern int SetWindowPos(IntPtr hWnd, int  hWndInsertAfter, int x, int y, int Width, int Height, int flags);
        [DllImport("user32.dll", CharSet = CharSet.Auto)] //设置窗体位置和高度
        private static extern System.IntPtr GetForegroundWindow();

class FindWindow
        {
            [DllImport("user32")]
            [return: MarshalAs(UnmanagedType.Bool)]
            //IMPORTANT : LPARAM  must be a pointer (InterPtr) in VS2005, otherwise an exception will be thrown
            private static extern bool EnumChildWindows(IntPtr window, EnumWindowProc callback, IntPtr i);
            //the callback function for the EnumChildWindows
            private delegate bool EnumWindowProc(IntPtr hWnd, IntPtr parameter);

            //if found  return the handle , otherwise return IntPtr.Zero
            [DllImport("user32.dll", EntryPoint = "FindWindowEx", CharSet = CharSet.Unicode)]
            private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);

            private string m_classname; // class name to look for
            private string m_caption; // caption name to look for

            private DateTime start;
            private int m_timeout;//If exceed the time. Indicate no windows found.

            private IntPtr m_hWnd; // HWND if found
            public IntPtr FoundHandle
            {
                get { return m_hWnd; }
            }

            private bool m_IsTimeOut;
            public bool IsTimeOut
            {
                get { return m_IsTimeOut; }
                set { m_IsTimeOut = value; }
            }

            // ctor does the work--just instantiate and go
            public FindWindow(IntPtr hwndParent, string classname, string caption, int timeout)
            {
                m_hWnd = IntPtr.Zero;
                m_classname = classname;
                m_caption = caption;
                m_timeout = timeout;
                start = DateTime.Now;
                FindChildClassHwnd(hwndParent, IntPtr.Zero);
            }

         
            private bool FindChildClassHwnd(IntPtr hwndParent, IntPtr lParam)
            {
                EnumWindowProc childProc = new EnumWindowProc(FindChildClassHwnd);
                IntPtr hwnd = FindWindowEx(hwndParent, IntPtr.Zero, m_classname, m_caption);
                if (hwnd != IntPtr.Zero)
                {
                    this.m_hWnd = hwnd; // found: save it
                    m_IsTimeOut = false;
                    return false; // stop enumerating
                }
                DateTime end = DateTime.Now;

                if (start.AddSeconds(m_timeout) < end)
                {
                    m_IsTimeOut = true;
                    return false;
                }
                EnumChildWindows(hwndParent, childProc, IntPtr.Zero); // recurse  redo FindChildClassHwnd
                return true;// keep looking
            }
        }

public string executeCmd(string Command)
        {
            Process process = new Process
            {
                StartInfo = { FileName = " cmd.exe ", UseShellExecute = false, RedirectStandardInput = true, RedirectStandardOutput = true, CreateNoWindow = true }
            };
            process.Start();
            process.StandardInput.WriteLine(Command);
            process.StandardInput.WriteLine("exit");
            process.WaitForExit();
            string str = process.StandardOutput.ReadToEnd();
            process.Close();
            return str;
        }

private void wB_MainBrowser_NewWindow(object sender, CancelEventArgs e)
        {
            e.Cancel = true;
            try
            {
                string url = this.webBrowser1.Document.ActiveElement.GetAttribute("href");
                this.webBrowser1.Url = new Uri(url);
            }
            catch
            {
            }
        }

        private void SetAllWebItemblank(HtmlElementCollection items)
        {
            try
            {
                foreach (HtmlElement item in items)
                {
                    if (item.TagName.ToLower().Equals("iframe", StringComparison.OrdinalIgnoreCase) == false)
                    {
                        try
                        {
                            item.SetAttribute("target", "_blank");
                        }
                        catch
                        { }
                    }
                    else
                    {
                        try
                        {
                            HtmlElementCollection fitems = item.Document.Window.Frames[item.Name].Document.All;
                            this.SetAllWebItemblank(fitems);
                        }
                        catch
                        { }
                    }
                }
            }
            catch
            {
            }
        }
        private void SetAllWebItemSelf(HtmlElementCollection items)
        {
            try
            {
                foreach (HtmlElement item in items)
                {
                    if (item.TagName.ToLower().Equals("iframe", StringComparison.OrdinalIgnoreCase) == false)
                    {
                        try
                        {
                            item.SetAttribute("target", "_self");
                        }
                        catch
                        { }
                    }
                    else
                    {
                        try
                        {
                            HtmlElementCollection fitems = item.Document.Window.Frames[item.Name].Document.All;
                            this.SetAllWebItemSelf(fitems);
                        }
                        catch
                        { }
                    }
                }
            }
            catch
            {
            }
        }

    private void webBrowser1_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
        {

            if (webBrowser1.DocumentTitle.IndexOf("你网站的标题") > -1)
            {
                try
                {
                    webBrowser1.WebBrowserShortcutsEnabled = true;
                    string fixthat = @"background-color: #6CF;
	height: 400px;
	width: 600px;
	border: 1px solid #666;
	background-image: url(http://自己要用的网站，也是程序的背景, 此段也是控制主窗口的显示/backpic.aspx);
	background-repeat: no-repeat;
	position:absolute;
	left:50%;
	top:50%;
	margin-top:-200px;
	margin-left: -300px;";
                    HtmlElementCollection godlike = webBrowser1.Document.Body.All;
                    string suckyou = @"<span id='suckyou' style='position: absolute;left: 6px;top: 6px;color:rgb(0, 0, 0);display: inline-block;width: 160px;white-space: nowrap;font-family:微软雅黑;font-size:16px;font-weight: bold;'>柠檬版Web      :D</span>";
                     //你自己需要对网页注入的代码JS或者CSS
                    foreach (HtmlElement X in godlike)
                    {
                        if (X.Parent.InnerText == "登录" || X.Parent.InnerText == "注销")
                        {
                            X.Parent.Parent.Parent.Style = fixthat;
                            X.Parent.Parent.FirstChild.NextSibling.NextSibling.FirstChild.Style += "display:none"; //对网页子元素进行修改
                            X.Parent.Parent.FirstChild.NextSibling.NextSibling.FirstChild.OuterHtml += suckyou;
                        }
                    }
            ｝