MARKUS



using log4net;

using RestSharp;

using System;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Net.Http;

using System.Net.Http.Headers;

using System.Threading.Tasks;

namespace DownloadManager

{

    class Program

    {

        private static ILog logger = LogManager.GetLogger(typeof(Program));

        private static string TEMP_FOLDER = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "MARKUS");

        static IIpc.WcfClient wcfClient;

        static bool IsDownload;

        static bool IsDebug;

        static int TotalPages = 0;

        //private const string SECTION_DOWNLOAD_FILE = "DOWNLOAD_FILE";

        //private const string SECTION_DOWNLOAD_DIR = "DOWNLOAD_DIR";

        //private const string KEY_VALUES = "VALUE";

        //private static string DOWNLOAD_LOG_FILE = System.IO.Path.Combine(TEMP_FOLDER, "Download.log");

        //private static ConfigParser DOWNLOAD_LOG = new ConfigParser(DOWNLOAD_LOG_FILE,

        //                                            new ConfigParserSettings

        //                                            {

        //                                                MultiLineValues = MultiLineValues.Simple | MultiLineValues.AllowValuelessKeys | MultiLineValues.QuoteDelimitedValues,

        //                                                Culture = new CultureInfo("en-US")

        //                                            });

        private static void ChangeLogFileName(string name)

        {

            log4net.Repository.ILoggerRepository RootRep;

            RootRep = logger.Logger.Repository;// LogManager.GetRepository(Assembly.GetCallingAssembly());

            if (RootRep?.GetAppenders().Count() > 0)

            {

                (RootRep.GetAppenders().First() as log4net.Appender.RollingFileAppender).File = string.Format((RootRep.GetAppenders().First() as log4net.Appender.RollingFileAppender).File, name);

                (RootRep.GetAppenders().First() as log4net.Appender.RollingFileAppender).ActivateOptions();

            }

        }

        static void Main(string[] args)

        {

            try

            {

                ChangeLogFileName($"{DateTime.Now.ToString("yyMMddssmm")}_{args[0]}");

                logger.Info($"param : {string.Join(",", args)}");

                if (args.Length > 0)

                {

                    for (int i = 0; i < args.Length; i++)

                    {

                        ConsoleWrite(args[i]);

                    }

                    //if (args[0] == IIpc.ProcessTypeDefine.DEFINE_DELETE)

                    //{

                    //    IsDebug = bool.Parse(args[1]);

                    //    DeleteFiles();

                    //}

                    if (args[0] == IIpc.ProcessTypeDefine.DEFINE_MONITOR)

                    {

                        IsDebug = bool.Parse(args[1]);

                        int processId = int.Parse(args[2]); /// kcom process id

                        int thumbnamilPID = int.Parse(args[3]);

                        int filePID = int.Parse(args[4]);

                        string folder1 = args[5];              // folder

                        string folder2 = args[6];              // folder

                        string file = args[7];              // file

                        string baseUri = args[8];              // uri

                        CheckAutoUpdate.Validation(baseUri);

                        try

                        {

                            Process process = FindProcess(processId);

                            while (process != null)

                            {

                                process = FindProcess(processId);

                                ConsoleWrite("Process Check");

                                System.Threading.Thread.Sleep(10000);

                            }

                            var p1 = FindProcess(thumbnamilPID);

                            if (p1 != null)

                            {

                                p1.Kill();

                            }

                            var p2 = FindProcess(filePID);

                            if (p2 != null)

                            {

                                p2.Kill();

                            }

                        }

                        catch (Exception ex)

                        {

                            ConsoleWrite(ex.ToString());

                        }

                        DeleteFiles(IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL, folder1);

                        DeleteFiles(IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL, folder2);

                        DeleteFiles(IIpc.ProcessTypeDefine.DEFINE_FILE, file);

                    }

                    else

                    {

                        wcfClient = new IIpc.WcfClient(args[1]);

                        IsDebug = bool.Parse(args[2]);

                        if (args[0] == IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL)

                        {

                            string BaseUri = args[3];

                            string localStoragePath = args[4];

                            string fileExt = args[5];

                            int totalPages = int.Parse(args[6]);

                            int takeCount = int.Parse(args[6]);

                            TotalPages = totalPages;

                            KCOM.PageManager.PageStorage pageStorage = new KCOM.PageManager.PageStorage(BaseUri, localStoragePath, fileExt, totalPages, takeCount);

                            pageStorage.PageLoadCompleted += PageStorage_PageLoadCompleted;

                            pageStorage.DownloadWork(1, totalPages);

                        }

                        else if (args[0] == IIpc.ProcessTypeDefine.DEFINE_FILE)

                        {

                            using (System.Net.WebClient client = new System.Net.WebClient())

                            {

                                client.DownloadFileCompleted += Client_DownloadFileCompleted;

                                client.DownloadProgressChanged += Client_DownloadProgressChanged;

                                client.UseDefaultCredentials = true;

                                System.Net.IWebProxy webProxy = client.Proxy;

                                if (webProxy != null)

                                {

                                    webProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;

                                }

                                client.DownloadFileAsync(new Uri(System.Web.HttpUtility.UrlDecode(args[3])), args[4]);

                            }

                        }

                        else if (args[0] == IIpc.ProcessTypeDefine.DEFINE_REST_FILE)

                        {

                            var result = RestDownloadAsync(System.Web.HttpUtility.UrlDecode(args[3]), args[4]).GetAwaiter().GetResult();

                            if (!IsDebug)

                                wcfClient.SendFileDownloadReceived(100, true);

                            ConsoleWrite($"Download stream {args[4]} Completed");

                            IsDownload = result;

                            //var client = new RestClient(System.Web.HttpUtility.UrlDecode(args[3]));

                            //client.Timeout = -1;

                            //var request = new RestRequest(Method.GET);

                            //IRestResponse response = client.Execute(request);

                            //var fileInfo = new FileInfo(args[4]);

                            //using (var fileStream = fileInfo.OpenWrite())

                            //{

                            //    int position = 0;

                            //    int step = 300000;

                            //    int length = 300000;

                            //    while (position < response.RawBytes.Length)

                            //    {

                            //        if (position + step < response.RawBytes.Length)

                            //        {

                            //            length = position + step;

                            //        }

                            //        else

                            //        {

                            //            length = response.RawBytes.Length - position;

                            //        }

                            //        fileStream.Write(response.RawBytes, position, length);

                            //        position = position + step;

                            //    }

                            //    if (!IsDebug)

                            //        wcfClient.SendFileDownloadReceived(100, true);

                            //    ConsoleWrite($"Download stream {args[4]} Completed");

                            //    IsDownload = true;

                            //}

                        }

                        while (!IsDownload)

                        {

                            System.Threading.Thread.Sleep(1000);

                        }

                    }

                    if (IsDebug)

                    {

                        Console.ReadLine();

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"param : {string.Join(",", args)}", ex);

                System.Diagnostics.Debug.WriteLine(ex);

            }

        }

        private static async Task<bool> RestDownloadAsync(string uri, string savePath)

        {

            bool result = false;

            try

            {

                var client = new RestClient(uri);

                client.Timeout = -1;

                var request = new RestRequest(Method.GET);

                IRestResponse response = await client.ExecuteAsync(request);

                if (response.StatusCode == System.Net.HttpStatusCode.OK)

                {

                    var fs = File.Create(savePath);

                    await fs.WriteAsync(response.RawBytes, 0, response.RawBytes.Length);

                    fs.Close();

                    result = true;

                }

            }

            catch (Exception ex)

            {

                logger.Error($"RestDownloadAsync : {uri} {savePath}", ex);

            }

            return result;

        }

        public static void DeleteFiles(string processType, string path)

        {

            try

            {

                logger.Info($"DeleteFiles Info {processType} {path}");

                if (processType == IIpc.ProcessTypeDefine.DEFINE_THUMBNAIL)

                {

                    var dir = System.IO.Directory.GetDirectories(path, "*.*", System.IO.SearchOption.AllDirectories);

                    for (int i = 0; i < dir.Length; i++)

                    {

                        System.IO.Directory.Delete(dir[i], true);

                    }

                }

                else

                {

                    if (System.IO.File.Exists(path))

                    {

                        System.IO.File.Delete(path);

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"DeleteFiles Error {processType} {path}", ex);

                System.Diagnostics.Debug.WriteLine(ex);

            }

        }

        private static Process FindProcess(int id)

        {

            Process result = null;

            try

            {

                var process = Process.GetProcesses().Where(x=>x.Id == id);

                if(process.Count()> 0)

                {

                    result = process.First();

                }

            }

            catch (Exception ex)

            {

                logger.Error($"FindProcess Error {id}", ex);

                System.Diagnostics.Debug.WriteLine(ex);

            }

            return result;

        }

        private static void ConsoleWrite(string data)

        {

            logger.Info(data);

            if (IsDebug)

            {

                Console.WriteLine(data);

            }

        }

        private static void Client_DownloadFileCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)

        {

            try

            {

                wcfClient.SendFileDownloadReceived(100, true);

                ConsoleWrite($"Download file Completed");

                IsDownload = true;

            }

            catch (Exception ex)

            {

                ConsoleWrite(ex.ToString());

            }

        }

        private static void Client_DownloadProgressChanged(object sender, System.Net.DownloadProgressChangedEventArgs e)

        {

            try

            {

                wcfClient.SendFileDownloadReceived(e.ProgressPercentage, false);

                ConsoleWrite($"Download file {e.ProgressPercentage}");

            }

            catch (Exception ex)

            {

                ConsoleWrite(ex.ToString());

            }

        }

        private static void PageStorage_PageLoadCompleted(object sender, KCOM.PageManager.PageLoadCompletedEventArgs e)

        {

            try

            {

                wcfClient.SendThumbnailReceived(e.PageItem.PageNo, e.PageItem.LocalFilePath,e.IsLast);

                ConsoleWrite($"{e.PageItem.PageNo} {e.PageItem.LocalUri}");

                if (e.PageItem.PageNo == TotalPages)

                {

                    IsDownload = true;

                }

            }

            catch (Exception ex)

            {

                ConsoleWrite(ex.ToString());

            }

        }

    }

}