HORIZON PROJECT

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Net;

using System.Xml;

using System.IO;

using System.Threading;

namespace Horizon

{

    public delegate void UpdateProgressCallback(int entireProgress, int partProgress);

    public class UpdateClient

    {

        public class NewFileInfo

        {

            public NewFileInfo(string path, DateTime lastWriteTime, long size)

            {

                this.path = path;

                this.lastWriteTime = lastWriteTime;

                this.size = size;

            }

            public override string ToString()

            {

                return path;

            }

            public long size;

            public string path;

            public DateTime lastWriteTime;

            public long oldLength = 0;

        }

        Queue<NewFileInfo> updateQueue = new Queue<NewFileInfo>();

        int needUpdateCount;

        UpdateProgressCallback progressCallback;

        XmlDocument updateXML = new XmlDocument();

        string defaultPath = @"Program\";

        string url;

        string project;

        public bool isUpdate;

        public UpdateClient()

        {

            if (!Directory.Exists("Program"))

            {

                Directory.CreateDirectory("Program");

            }

        }

        public enum RST_GetUpdateList { SUCCESS, FAIL_NETWORK, FAIL_XMLFORMAT }

        public RST_GetUpdateList GetUpdateList(string url, string project)

        {

            WebClient client = new WebClient();

            this.url = url;

            this.project = project;

            string xml;

            try

            {

               // xml = client.DownloadString(url + project + @"\UpdateLog.xml");

            }

            catch

            {

                return RST_GetUpdateList.FAIL_NETWORK;

            }

            try

            {

               // updateXML.LoadXml(xml);

            }

            catch

            {

                return RST_GetUpdateList.FAIL_XMLFORMAT;

            }

            XmlElement root = updateXML.DocumentElement;

            XmlNodeList files = root.ChildNodes;

            foreach (XmlNode file in files)

            {

                string path = file.FirstChild.InnerText;

                string length = file.ChildNodes[1].InnerText;

                string wt = file.ChildNodes[2].InnerText;

                if (IsNeedUpdate(path, DateTime.Parse(wt), length))

                {

                    updateQueue.Enqueue(new NewFileInfo(path, DateTime.Parse(wt), long.Parse(length)));

                }

            }

            needUpdateCount = updateQueue.Count;

            client.Dispose();

            return RST_GetUpdateList.SUCCESS;

        }

        private bool IsNeedUpdate(string path, DateTime writeTime, string length)

        {

            string localPath = defaultPath + path;

            FileInfo info;

            try

            {

                info = new FileInfo(localPath);

            }

            catch

            {

                return false;

            }

            if (info.Exists)

            {

                string size = info.Length.ToString();

                DateTime time = info.LastWriteTime;

                return !(time.Equals(writeTime) && size.Equals(length));

            }

            else

            {

                try

                {

                    string dirPath = localPath.Substring(0, localPath.LastIndexOf(@"\"));

                    Directory.CreateDirectory(dirPath);

                }

                catch

                {

                    return false;

                }

                return true;

            }

        }

        WebClient updateClient;

        public void StartUpdate(UpdateProgressCallback callback)

        {

            //Console.WriteLine(needUpdateCount);

            if (needUpdateCount == 0)

            {

                isUpdate = false;

                callback(100, 100);

                return;

            }

            isUpdate = true;

            progressCallback = callback;

            Update();

        }

        void Update()

        {

            if (updateQueue.Count == 0)

            {

                if (updateClient != null)

                    updateClient.Dispose();

                isUpdate = false;

                return;

            }

            DoDownloadFile(updateQueue.Dequeue());

        }

        private async void DoDownloadFile(NewFileInfo info)

        {

            bool isSuccess = false;

            long totalBytesRead = 0;

            using (FileStream localFileStream = new FileStream(defaultPath + info, FileMode.Create))

            {

                while (!isSuccess)

                {

                    try

                    {

                        HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(url + project + "/" + info);

                        httpRequest.Method = "GET";

                        httpRequest.AddRange(totalBytesRead, info.size);

                        // if the URI doesn't exist, exception gets thrown here...

                        using (HttpWebResponse httpResponse = (HttpWebResponse)httpRequest.GetResponse())

                        {

                            using (Stream responseStream = httpResponse.GetResponseStream())

                            {

                                var buffer = new byte[4096];

                                int bytesRead;

                                while ((bytesRead = await responseStream.ReadAsync(buffer, 0, buffer.Length)) > 0)

                                {

                                    totalBytesRead += bytesRead;

                                    progressCallback((int)((1.0f - ((float)updateQueue.Count / needUpdateCount)) * 100), (int)((float)totalBytesRead / info.size * 100));

                                    await localFileStream.WriteAsync(buffer, 0, bytesRead);

                                }

                            }

                        }

                        localFileStream.Close();

                        FileInfo file = new FileInfo(defaultPath + info.path);

                        file.LastWriteTime = info.lastWriteTime;

                        isSuccess = true;

                    }

                    catch (Exception ex)

                    {

                        Thread.Sleep(100);

                    }

                }

            }

            Update();

        }

        public static string[] GetProjectList(string ftpAddress)

        {

            FtpWebRequest ftpRequest;

            try

            {

                ftpRequest = (FtpWebRequest)(WebRequest.Create(ftpAddress));

                ftpRequest.Method = WebRequestMethods.Ftp.ListDirectory;

                ftpRequest.Credentials = new NetworkCredential("FTPUser", "1234");

                ftpRequest.UseBinary = true;

            }

            catch

            {

                return null;

            }

            try

            {

                FtpWebResponse respone = (FtpWebResponse)ftpRequest.GetResponse();

                StreamReader reader = new StreamReader(respone.GetResponseStream(), Encoding.Default);

                string data = reader.ReadToEnd();

                if (respone != null)

                {

                    respone.Close();

                }

                return data.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);

            }

            catch

            {

                return null;

            }

        }

    }

}