MARKUS

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics;

using System.IO;

using System.Net;

using System.Threading;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Input;

using System.Xml;

using System.Drawing;

using System.Windows.Media;

using Image = System.Windows.Controls.Image;

using System.Windows.Media.Imaging;

using System.Text;

using System.Runtime.InteropServices;

using System.Security;

namespace SmartUpdate

{

    /// <summary>

    /// MainWindow.xaml에 대한 상호 작용 논리

    /// </summary>

    public partial class MainWindow : Window

    {

        private int index = 0; //업데이트시 파일 하나씩 넘어가게 하기 위해서

        private bool check = false; //다운완료된것 체크

        private int lastIndex;

        private Thread theProgBarThread;

        private bool m_bLoop;        

        private string versionPath = null; //64, 86 버전에 따른 서버 파일 위치        

        private string[] strArg; //KCOM 접속 파라미터 값 받기 위해        

        private int c_index = 1; //마지막 파일 확인 후 종료하기 위해        

        private string msgFileName = SmartUpdate.Properties.Settings.Default.msgFileName; //메시지창에 띄워줄 프로그램명        

        private string FileName = SmartUpdate.Properties.Settings.Default.FileName; //실행파일명

        public MainWindow()

        {

            InitializeComponent();            

            WindowStartupLocation = WindowStartupLocation.CenterOwner; //창 가운데로

            WindowStartupLocation = WindowStartupLocation.CenterScreen; //창 가운데로            

            Topmost = true; //창 최상위로

            this.Loaded += new RoutedEventHandler(MainWindow_Loaded);

        }

        void MainWindow_Loaded(object sender, RoutedEventArgs e)

        {           

            m_bLoop = true;

            lastIndex = index = 0;

            theProgBarThread = new Thread(new ThreadStart(Step));

            theProgBarThread.Start();

            Thread.Sleep(100);

            PartialDownloadProgressBar.Maximum = 100;            

            strArg = Environment.GetCommandLineArgs(); //KCOM 접속 파라미터 값 받기 위해            

            ConnectUpgradeServer(); //여기서부터 XML 파싱 및 파일 다운로드

        }

        public class ItemInfo

        {

            public string FileName { get; set; }

            public string Version { get; set; }

            public ImageSource SIcon { get; set; }

        }

        List<ItemInfo> itemInfoList = new List<ItemInfo>();

        List<ItemInfo> downloadList = new List<ItemInfo>();

        private void SetXmlParseing() 

        {            

            try

            {

                XmlDocument xdoc = new XmlDocument();              

                if (Environment.Is64BitProcess == true) //64 bit machine

                {

                    versionPath = SmartUpdate.Properties.Settings.Default.UpdateVer64;

                }

                else //32 bit machine

                {

                    versionPath = SmartUpdate.Properties.Settings.Default.UpdateVer86;

                }

                // XML 데이타를 파일에서 로드

                xdoc.Load(versionPath);

                // 특정 노드들을 필터링

                XmlNodeList nodes = xdoc.SelectNodes("/RootElement/Item");

                foreach (XmlNode emp in nodes)

                {

                    string Filename = emp.SelectSingleNode("Filename").InnerText;

                    string Version = emp.SelectSingleNode("Version").InnerText;                    

                    try

                    {

                        //해당 파일이 서버에 있는지 확인

                        HttpWebRequest webreq = (HttpWebRequest)WebRequest.Create(Filename);

                        HttpWebResponse webres = (HttpWebResponse)webreq.GetResponse();

                        webres.Close();

                        webreq = null;

                        webres = null;

                        if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + @Path.GetFileName(Filename))) //해당 파일이 클라이언트에 있는가?

                        {

                            if (IsAccessAble(AppDomain.CurrentDomain.BaseDirectory + @Path.GetFileName(Filename)) == false) //다운받으려는 파일이 다른곳에서 점유중인지 확인.

                            {

                                ErrorLogFileWrite("실행중인 파일로 인해 업데이트 실패 : " + @Path.GetFileName(Filename));

                                SmartUpdateExit("실행중인 "+ msgFileName + "가 있습니다. \n모두 닫은 후 다시 실행해주세요."); //스마트 업데이트 종료

                            }

                            else if (FileVersionInfo.GetVersionInfo(AppDomain.CurrentDomain.BaseDirectory + @Path.GetFileName(Filename)).FileVersion != Version) //두개의 버전이 다른가?

                            {

                                itemInfoList.Add(new ItemInfo() { FileName = Filename, Version = Version });                               

                                ImageSource icon = IconManager.GetIcon(@Path.GetFileName(Filename), false, false);                                

                                downloadList.Add(new ItemInfo() { FileName = @Path.GetFileName(Filename), Version = Version, SIcon = icon });

                            }

                        }

                        else

                        {

                            itemInfoList.Add(new ItemInfo() { FileName = Filename, Version = Version });

                            ImageSource icon = IconManager.GetIcon(@Path.GetFileName(Filename), false, false);

                            downloadList.Add(new ItemInfo() { FileName = @Path.GetFileName(Filename), Version = Version, SIcon = icon });

                        }                        

                    }

                    catch(Exception ex) //다운로드 받아야할 파일이 서버에 없을 경우 스마트업데이트 강제 종료.

                    {

                        ErrorLogFileWrite("Err : " + ex);

                        SmartUpdateExit("서버에 파일이 없습니다.");

                    }

                }

                downloadlist.ItemsSource = downloadList;

                SetDown();                  

            }

            catch(Exception ex) //version.xml 파일이 없을 경우 스마트업데이트 강제 종료.

            {

                ErrorLogFileWrite("Err : " + ex);

                SmartUpdateExit("File Loading Error SmartUpdate를 종료합니다."); //스마트 업데이트 종료

            }                 

        }

        private void SetDown()

        {

            try

            {                

                for (int i = 0; i < itemInfoList.Count; i++)

                {

                    WebClient theDownloadThread = new WebClient();

                    Uri url = new Uri(itemInfoList[i].FileName);

                    theDownloadThread.DownloadProgressChanged += new DownloadProgressChangedEventHandler(DownloadProgressChanged);   

                    theDownloadThread.DownloadFileCompleted += new AsyncCompletedEventHandler(Completed);

                    string filename = Path.GetFileName(itemInfoList[i].FileName);

                    theDownloadThread.DownloadFileAsync(url, AppDomain.CurrentDomain.BaseDirectory + filename);

                }               

            }

            catch(Exception ee) //다운로드 도중 에러시 스마트업데이트 강제 종료. 

            {

                ErrorLogFileWrite("SetDown()  \r\n 상세로그 : " + ee);

                SmartUpdateExit("File Download Error SmartUpdate를 종료합니다."); //스마트 업데이트 종료

            }            

        }

        private void ConnectUpgradeServer()

        {

            try

            {              

                SetXmlParseing();                

            }

            catch (Exception er)

            {

                string strError = er.ToString();

                MarkusStart(strError);

            }

        }

        private void MarkusStart(string MessageStr)

        {

            try

            {

                ErrorLogFileWrite("상세로그 : " + MessageStr);

                ProcessStartInfo proInfo = new ProcessStartInfo();

                proInfo.FileName = AppDomain.CurrentDomain.BaseDirectory + FileName;

                if (strArg.Length > 1)

                {

                    proInfo.Arguments = strArg[1];

                }

                Process.Start(proInfo);

                //현재 실행되고 있는 자기 자신 프로세스의 정보

                Process proc = Process.GetCurrentProcess();

                proc.Kill();

            }

            catch (Exception ee)

            {

                ErrorLogFileWrite("Err로그 : " + ee);

                //MessageBox.Show(ee + "MARKUS를 재실행 해주시기 바랍니다.");

            }

        }

        private void SmartUpdateExit(string MessageStr)

        {

            try

            {

                MessageBox.Show(MessageStr, "종료합니다.", MessageBoxButton.OK);

                //현재 실행되고 있는 자기 자신 프로세스의 정보

                Process proc = Process.GetCurrentProcess();

                proc.Kill();

            }

            catch //(Exception ex)

            {

                ErrorLogFileWrite("SmartUpdateExit()  \r\n 상세로그 : " + MessageStr);

            }

        }

        //http://blog.naver.com/PostView.nhn?blogId=nersion&logNo=140150987526&parentCategoryNo=&categoryNo=56&viewDate=&isShowPopularPosts=true&from=search

        private bool IsAccessAble(String path)

        {

            FileStream fs = null;

            try

            {

                //앞단에서 파일이 있는 경우에만 타도록 했음 그렇지 않으면 파일 자체가 없을때도 false 반환

                fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);                                

            }

            catch (IOException)

            {

                //에러가 발생한 이유는 이미 다른 프로세서에서 점유중.               

                return false;

            }

            finally

            {

                if (fs != null)

                {

                    //만약에 파일이 정상적으로 열렸다면 점유중이 아니다.

                    //다시 파일을 닫아줘야 한다.

                    fs.Close();

                }

            }

            return true;

        }

        protected XmlNode CreateNode(XmlDocument xmlDoc, string name, string innerXml)

        {

            XmlNode node = xmlDoc.CreateElement(string.Empty, name, string.Empty);

            node.InnerXml = innerXml;

            return node;

        }

        private void Step()

        {

            while (m_bLoop)

            {

                if (lastIndex < index)

                {

                    lastIndex++;

                }

                Thread.Sleep(1000);

            }

        }

        private void Completed(object sender, AsyncCompletedEventArgs e)

        {

            c_index++;

            if (c_index > itemInfoList.Count)

            {

                try

                {                 

                    ProcessStartInfo proInfo = new ProcessStartInfo();

                    proInfo.FileName = AppDomain.CurrentDomain.BaseDirectory + FileName;

                    if (strArg.Length > 1)

                    {

                        proInfo.Arguments = strArg[1];

                    }

                    Process.Start(proInfo);

                    //현재 실행되고 있는 자기 자신 프로세스의 정보

                    Process proc = Process.GetCurrentProcess();

                    proc.Kill();

                }

                catch (Exception ee)

                {

                    ErrorLogFileWrite("SmartUpdate 종료 또는 "+ msgFileName + "실행에 실패했습니다.  \r\n 상세로그 : " + ee);

                    //MessageBox.Show(strArg[1] + "MARKUS를 재실행 해주시기 바랍니다.");

                }

            }

        }

        //파일 다운로드 상황을 반영한다.

        private void DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)

        {

            //PartialDownloadProgressBar.Value = e.ProgressPercentage;               

            //이전에 다운로드 받은 파일이 완료되었다면

            if (e.TotalBytesToReceive == e.BytesReceived && !check)

            {

                if (index < itemInfoList.Count)

                {

                    index++;

                    PartialDownloadProgressBar.Value = (Convert.ToDouble(index) / Convert.ToDouble(itemInfoList.Count)) * 100;

                    LogFileWrite();

                }                

            }

            else

            {

                check = false;

            }

        }

        private void ErrorLogFileWrite(string Err)

        {

            try

            {

                string pathString = App.AppDataFolder + "\\SmartUpdate";

                if (!File.Exists(pathString))

                {                    

                    Directory.CreateDirectory(pathString);

                }

                Err = Err + "   " +DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss")  + "\r\n";

                string path = pathString + "\\" + "Log_" + DateTime.Now.ToString("yyyy-MM-dd hh-mm") + ".txt";

                File.AppendAllText(path, Err);

            }

            catch (Exception er)

            {

                string strError = er.ToString();

            }

        }

        private void LogFileWrite()

        {

            try

            {

                string pathString = App.AppDataFolder + "\\SmartUpdate";

                if (!File.Exists(pathString))

                {                    

                    Directory.CreateDirectory(pathString);

                }                   

                FileStream fs = new FileStream(pathString + "\\Log_" + DateTime.Now.ToString("yyyy-MM-dd hh-mm-ss") + ".txt", FileMode.OpenOrCreate, FileAccess.Write);

                StreamWriter sw = new StreamWriter(fs);

                sw.WriteLine("<업그레이드 정보>");

                sw.WriteLine("<업데이트 날짜>");

                sw.WriteLine("{0}", DateTime.Today.ToLongDateString());

                sw.WriteLine("<업데이트 파일>");

                for (int i = 0; i < itemInfoList.Count; i++)

                    sw.WriteLine("{0}", itemInfoList[i].FileName);

                sw.Close();

                fs.Close();

            }

            catch (Exception er)

            {

                string strError = er.ToString();

                ErrorLogFileWrite("업데이트 파일 작성에 실패했습니다.  \r\n 상세로그 : " + strError);

            }

        }

        private void WinState(object sender, MouseButtonEventArgs e)

        {

            switch ((e.Source as Image).Name)

            {

                case ("Win_min"):

                    {

                        WindowState = WindowState.Minimized;

                    }

                    break;

                case ("Win_max"):

                    {

                        if (WindowState == WindowState.Maximized)

                        {

                            WindowState = WindowState.Normal;

                        }

                        else

                        {

                            WindowState = WindowState.Maximized;

                        }

                    }

                    break;

                case ("Win_Close"):

                    {                       

                        this.Close();

                    }

                    break;

            }

        }

    }

}