MARKUS

using log4net;

using Markus.Message;

using Markus.Service.Helper;

using Markus.Service.Interface;

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Net.Http;

using System.ServiceModel;

using System.Text;

using Markus.Service.Extensions;

using Markus.Service.WcfClient.StationServiceAsync;

using System.Threading.Tasks;

using System.Web;

using RestSharp;

namespace Markus.Service.Convert

{

    public class ConvertService : IDisposable

    {

        // 1GigaBytes

        protected ILog logger;

        readonly ProcessContext ConvertProcessContext;

        private string gTempFileName;

        private Markus.SaveTask gSaveTask;

        private Markus.MarkusPDF gMarkusPDF;

        // 컨버터 완료시 파일갯수를 체크 하여 틀리면 reconvert를 1로 하고 다시 컨버팅 하도록 한다.

        private int ReConvert;

        private StationServiceClient StationServiceClient; 

        /// <summary>

        /// 프로세스 초기화

        /// </summary>

        /// <param name="convertContext"></param>

        public ConvertService(ProcessContext convertContext) : base()

        {

            logger = LogManager.GetLogger(typeof(ConvertService));

            ConvertProcessContext = convertContext;

            BasicHttpBinding myBinding = new BasicHttpBinding();

            EndpointAddress myEndpoint = new EndpointAddress(UriHelper.UriCreate(ConvertProcessContext.ServiceStationUri));

            StationServiceClient = new StationServiceClient(myBinding, myEndpoint);

            gMarkusPDF = new MarkusPDF();

            gSaveTask = new SaveTask();

            gSaveTask.StateChangeEvent += MarkusPdfStateChangeEvent;

        }

        public ConvertService()

        {

        }

        public void Dispose()

        {

            try

            {

                if(gMarkusPDF != null)

                {

                    gMarkusPDF.Dispose();

                    gMarkusPDF = null;

                }

                if (gSaveTask != null)

                {

                    gSaveTask.StateChangeEvent -= MarkusPdfStateChangeEvent;

                    gSaveTask.Dispose();

                    gSaveTask = null;

                }

                //if (System.IO.File.Exists(gTempFileName))

                //{

                //    File.Delete(gTempFileName);

                //}

            }

            catch (Exception ex)

            {

               logger.Error("Convert Service Dispose Error", ex);

            }

            finally

            {

                GC.Collect(2);

                GC.Collect(2);

            }

        }

        /// <summary>

        ///  markus lib에서 받는 이벤트

        /// </summary>

        /// <param name="sender"></param>

        /// <param name="e"></param>

        private void MarkusPdfStateChangeEvent(object sender, Markus.Message.StateEventArgs e)

        {

            try

            {

                int currentPage = e.SaveItem.CurrentPage;

                if (e.SaveItem.CurrentPage == 0)    /// 초기 wait status인 경우 0일수 있다. %계산시 오류 방지

                {

                    currentPage = 1;

                }

                switch (e.SaveItem.Status)

                {

                    case StatusCodeType.None:

                        break;

                    case StatusCodeType.Wait:

                        break;

                    case StatusCodeType.PageLoading:

                        break;

                    case StatusCodeType.Saving:

                        break;

                    case StatusCodeType.Completed:

                        break;

                    case StatusCodeType.FileError:

                        break;

                    case StatusCodeType.PageError:

                        break;

                    case StatusCodeType.NeedsPassword:

                        break;

                    case StatusCodeType.Error:

                        break;

                    default:

                        break;

                }

                StationServiceClient.ConvertProcessStateAsync(e.SaveItem.Id, (int)e.SaveItem.Status, e.SaveItem.CurrentPage, e.SaveItem.TotalPages, e.SaveItem.ErrorMessage);

            }

            catch (Exception ex)

            {

                logger.Error($"Status Change Error", ex);

            }

        }

        [System.Security.Permissions.FileIOPermission(System.Security.Permissions.SecurityAction.LinkDemand)]

        public async Task<SaveResult> SetFileAsync()

        {

            SaveResult result = new SaveResult();

            SaveItem saveitem = new SaveItem

            {

                Id = ConvertProcessContext.ConvertID,

                PdfFilePath = ConvertProcessContext.OriginFilePath,

                SavePath = ConvertProcessContext.SaveDirectory,

                Status = StatusCodeType.None,

                MinimumFontSize = ConvertProcessContext.MinFontSize,

                UseResolution = ConvertProcessContext.UseResolution

            };

            try

            {

                StationServiceClient.ConvertProcessState(ConvertProcessContext.ConvertID, (int)StatusCodeType.Wait, 0, 0, "");

                result = await ConvertAsync(saveitem);

                // 플러그인 실행

                PluginService.Run(saveitem.Id);

                this.Dispose();

                StationServiceClient.ConvertFinish(saveitem.Id, (int)result.StatusCode, saveitem.CurrentPage, saveitem.TotalPages,result.Message);

            }

            catch (Exception ex)

            {

                result.StatusCode = StatusCodeType.Error;

                logger.Error($"File Convert Error",ex);

                StationServiceClient.ConvertFinish(saveitem.Id, (int)result.StatusCode, saveitem.CurrentPage, saveitem.TotalPages, $"ConvertService Error    {saveitem.Id} {ex.Message} {ex.InnerException?.ToString()}");

            }

            return result;

        }

        [System.Security.Permissions.FileIOPermission(System.Security.Permissions.SecurityAction.LinkDemand)]

        private async Task<SaveResult> ConvertAsync(SaveItem saveitem)

        { 

            SaveResult result = new SaveResult();

            try

            {

                DateTime deleteTime = DateTime.Now;

                while (System.IO.Directory.Exists(saveitem.SavePath))

                {

                    try

                    {

                        System.IO.Directory.Delete(saveitem.SavePath, true);

                    }

                    catch (Exception)

                    {

                    }

                    if ((DateTime.Now - deleteTime) > new TimeSpan(0, 5, 0))

                    {

                        string msg = $"ConvertService Error {saveitem.SavePath} Delete Error";

                        logger.Error(msg);

                        result.StatusCode = StatusCodeType.FileError;

                        result.Message =  LogHelper.GetStack() + " " +LogHelper.GetStack() + " " + msg;

                        return result;

                    }

                    System.Threading.Thread.SpinWait(10);

                }

                System.IO.Directory.CreateDirectory(saveitem.SavePath);

                //파일 다운로드

                if (await DownloadFileAsync(saveitem))

                {

                    gTempFileName = saveitem.PdfFilePath;

                    if(gTempFileName.ToCharArray().Any(x=>x.IsKor()))

                    {

                        gTempFileName = Path.Combine(Path.GetTempPath(), GuidExtension.shortGuid() + ".pdf");

                        File.Copy(saveitem.PdfFilePath, gTempFileName,true);

                        System.Threading.Thread.Sleep(100);

                    }

                    gMarkusPDF.pdfLoad(gTempFileName, saveitem.MinimumFontSize, saveitem.UseResolution);

                    if(gMarkusPDF.PageCount() > 0)

                    {

                        /// 설정된 MultiThreadMaxPages에 따른 컨버터 분기

                        //if (gMarkusPDF.PageCount() > ConvertProcessContext.MultiThreadMaxPages)

                        //{

                        //    // 큰 사이즈의 파일 컨버팅

                          result = ConvertBigFileProcess(saveitem);

                        //}

                        //else

                        //{

                        //    /// 작은 사이즈의 컨버팅

                        //    await Task.Factory.StartNew(new Action(() =>

                        //    {

                        //        result = gSaveTask.SaveFile(saveitem);

                        //    }), TaskCreationOptions.LongRunning);

                        //}

                        // 파일 체크 후 갯수가 안맞으면 다시 컨버팅한다.

                        if (ReConvert < 1 && (result.PageInfoList.Count() != saveitem.TotalPages

                                       || Directory.EnumerateFiles(saveitem.SavePath, "*.png").Count() != saveitem.TotalPages

                                           || Directory.EnumerateFiles(saveitem.SavePath, "*.jpg").Count() != saveitem.TotalPages))

                        {

                            result.StatusCode = StatusCodeType.PageError;

                            result.Message =  LogHelper.GetStack() + " " +"Page Count Error";

                            ReConvert = 1;

                            result = ConvertBigFileProcess(saveitem);

                        }

                        ///  페이지 정보 저장

                        if (result.PageInfoList?.Count() > 0)

                        {

                            bool docSetResult = false;

                            using (Markus.Service.DataBase.ConvertDatabase database = new Markus.Service.DataBase.ConvertDatabase(ConvertProcessContext.ConnectionString))

                            {

                                List<EntityModel.DOCPAGE> docPageList = new List<EntityModel.DOCPAGE>();

                                docPageList = result.PageInfoList.Select(f => new EntityModel.DOCPAGE

                                {

                                    ID = GuidExtension.shortGuid(),

                                    PAGE_WIDTH = f.Width.ToString(),

                                    PAGE_HEIGHT = f.Height.ToString(),

                                    PAGE_NUMBER = f.PageNo

                                }).ToList();

                                docSetResult = database.SetDocumentInfo(saveitem.Id, result.PageInfoList.Count, docPageList);

                            }

                            if (docSetResult)

                            {

                                result.StatusCode = StatusCodeType.Completed;

                            }

                            else

                            {

                                result.StatusCode = StatusCodeType.FileError;

                                result.Message = LogHelper.GetStack() + " " + $"Doc Set Error. {result.Message}";

                            }

                        }

                        else

                        {

                            result.StatusCode = StatusCodeType.FileError;

                            result.Message = LogHelper.GetStack() + " " + $"Page List Get Error. {result.Message} ";

                        }

                    }

                    else

                    {

                        result.Message = $"File Error Page Count:0 - File path : { saveitem.PdfFilePath}";

                        result.StatusCode = StatusCodeType.FileError;

                    }

                }

                else

                {

                    result.Message  = $"File Download Error  - File path : { saveitem.PdfFilePath}";

                    result.StatusCode = StatusCodeType.FileError;

                }

            }

            catch (Exception ex)

            {

                result.Message =  LogHelper.GetStack() + " " +"ConvertService Convert Error" + ex.Message;

                result.StatusCode = StatusCodeType.Error;

                logger.Error(ex);

            }

            finally

            {

            }

            return result;

        }

        /// <summary>

        /// 파일 다운로드

        /// </summary>

        /// <param name="saveItem"></param>

        /// <returns></returns>

        public async Task<bool> DownloadFileAsync(SaveItem saveItem)

        {

            bool result = false;

            try

            {

                Uri pdfFileUri = null;

                //if (saveItem.PdfFilePath.Contains("VPCS_DOCLIB"))

                //{

                //    FileName = DocUri.Remove(0, DocUri.LastIndexOf("/") + 1);

                //    ProjectFolderPath = DownloadDir_PDF + "\\" + ConverterItem.PROJECT_NO + "_Tile"; //프로젝트 폴더

                //    ItemListPath = ProjectFolderPath + "\\" + (System.Convert.ToInt64(ConverterItem.DOCUMENT_ID) / 100).ToString();

                //    ItemPath = ItemListPath + "\\" + ConverterItem.DOCUMENT_ID;

                //    DownloadFilePath = ItemPath + "\\" + FileName;

                //}

                //else

                //{

                //    ProjectFolderPath = DownloadDir_PDF + "\\" + ConverterItem.PROJECT_NO + "_Tile"; //프로젝트 폴더

                //    ItemListPath = ProjectFolderPath + "\\" + (System.Convert.ToInt64(ConverterItem.DOCUMENT_ID) / 100).ToString();

                //    ItemPath = ItemListPath + "\\" + ConverterItem.DOCUMENT_ID;

                //    FileName = HttpUtility.ParseQueryString(new Uri(DocUri).Query).Get("fileName");

                //    DownloadFilePath = string.IsNullOrWhiteSpace(FileName) ? ItemPath + "\\" + FileName : ItemPath + "\\" + FileName;

                //}

                saveItem.PdfFilePath = HttpUtility.UrlDecode(saveItem.PdfFilePath); //PDF 전체 경로

                string FileName = "";

                string downloadFilePath = "";

                // 드라이브 경로가 포함되었는지 판단.

                if (Path.IsPathRooted(saveItem.PdfFilePath))

                {

                    FileInfo file = new FileInfo(saveItem.PdfFilePath);

                    if (file.Exists)

                    {

                        FileName = file.Name;

                        downloadFilePath = System.IO.Path.Combine(saveItem.SavePath, FileName);

                        file.CopyTo(downloadFilePath, true);

                    }

                    else

                    {

                        throw new Exception("File Not Found. Please, check the file path.");

                    }

                }

                else if (Uri.TryCreate(saveItem.PdfFilePath, UriKind.RelativeOrAbsolute, out pdfFileUri))

                {

                    try

                    {

                        downloadFilePath = await RestDownloadAsync(pdfFileUri, saveItem.SavePath);

                        /*bseng

   */

                        /* 벽산으로 임시 주석 

                        FileName = DownloadUri.GetFileName(saveItem.PdfFilePath);

                        downloadFilePath = System.IO.Path.Combine(saveItem.SavePath, FileName);

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

                         {

                             webClient.UseDefaultCredentials = true;//.Headers.Add("Authorization: BASIC SGVsbG8="); //가상의 인증

                             webClient.Proxy = null;

                             if (!System.IO.Directory.Exists(ConvertProcessContext.TempDirectory))

                             {

                                 System.IO.Directory.CreateDirectory(ConvertProcessContext.TempDirectory);

                             }

                             webClient.DownloadFile(pdfFileUri, downloadFilePath);

                             webClient.Dispose();

                         }

                       *    */

                        await Task.Delay(300);

                    }

                    catch (Exception ex)

                    {

                        logger.Error(ex);

                        throw new Exception($"File Download Error. Please, check the file path. {pdfFileUri}");

                    }

                }

                else

                {

                    throw new Exception("Please, check the file path.");

                }

                try

                {

                    if (File.Exists(downloadFilePath))

                    {

                        var file = File.Open(downloadFilePath, FileMode.Open);

                        if (file.Length == 0)

                        {

                            throw new Exception("File Size 0. Please, check the file path.");

                        }

                        file.Close();

                        file.Dispose();

                        saveItem.PdfFilePath = downloadFilePath;

                        result = true;

                    }

                }

                catch (Exception ex)

                {

                    logger.Error(ex);

                    throw new Exception("File Error ." + downloadFilePath);

                }

            }

            catch (Exception ex)

            {

                logger.Error(ex);

                throw new Exception(ex.ToString());

            }

            return result;

        }

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

        {

            string downloadFilePath = "";

            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 fileName = DownloadUri.GetFileNameInDisposition(new System.Net.Mime.ContentDisposition(response.Headers.Where(x => x.Name == "Content-Disposition").First().Value.ToString()));

                downloadFilePath = System.IO.Path.Combine(savePath, fileName);

                var fs = File.Create(downloadFilePath);

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

                fs.Close();

            }

            //var fileInfo = new FileInfo(downloadFilePath);

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

            //{

            //    await fileStream.WriteAsync(response.RawBytes, 0, response.RawBytes.Length);

            //    fileStream.Close();

            //    //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;

            //    //    }

            //    //    await fileStream.WriteAsync(response.RawBytes, position, length);

            //    //    position = position + step;

            //    //}

            //}

            return downloadFilePath;

        }

        /// <summary>

        /// 큰파일 변환

        /// </summary>

        /// <param name="saveitem"></param>

        /// <returns></returns>

        private SaveResult ConvertBigFileProcess(SaveItem saveitem)

        {

            SaveResult result = new SaveResult();

            try

            {

                saveitem.TotalPages = gMarkusPDF.PageCount();

                for (int currentPageNo = 1; currentPageNo <= saveitem.TotalPages; currentPageNo++)

                {

                    try

                    {

                        string saveFile = Path.Combine(saveitem.SavePath, $"{currentPageNo}.png");

                        if (ReConvert < 1 || (ReConvert == 1 && !File.Exists(saveFile)))

                         {

                            var saveResult = gMarkusPDF.SavePage(currentPageNo, saveFile);

                            saveitem.Status = StatusCodeType.Saving;

                            saveitem.CurrentPage = currentPageNo;

                            saveitem.ErrorMessage = saveResult.Message;

                            int pageListCount = 0;

                            if(result.PageInfoList != null)

                            {

                                pageListCount = result.PageInfoList.Count(f => f.PageNo == saveResult.SavePageInfo.PageNo);

                            }

                            if (pageListCount == 0)

                            {

                                result.PageInfoAdd(saveResult.SavePageInfo);

                            }

                            MarkusPdfStateChangeEvent(this, new StateEventArgs(saveitem));

                            Console.WriteLine($"CurrentPage : {currentPageNo}");

                            /// 설정된 최대 페이지이거나 설정된 메모리보다 크면 릴리즈

                            if ((currentPageNo % ConvertProcessContext.MultiThreadMaxPages == 0 && ConvertProcessContext.MultiThreadMaxPages  > 0)

                                || ConvertProcessContext.ReleaseWorkMemory < Environment.WorkingSet)

                            {

                                Console.WriteLine($"physical memory : {Environment.WorkingSet}");

                                gMarkusPDF.Dispose();

                                gMarkusPDF = null;

                                System.Threading.Thread.SpinWait(5);

                                gMarkusPDF = new MarkusPDF();

                                gMarkusPDF.pdfLoad(gTempFileName, saveitem.MinimumFontSize, saveitem.UseResolution);

                            }

                            System.Threading.Thread.SpinWait(2);

                        }

                    }

                    catch (Exception ex)

                    {

                        result.StatusCode = StatusCodeType.PageError;

                        result.Message =  LogHelper.GetStack() + " " +"Save Error - " + ex.Message;

                        if (gMarkusPDF != null)

                        {

                            gMarkusPDF.Dispose();

                            gMarkusPDF = null;

                        }

                        gMarkusPDF = new MarkusPDF();

                        gMarkusPDF.pdfLoad(gTempFileName, saveitem.MinimumFontSize, saveitem.UseResolution);

                        currentPageNo = currentPageNo - 1;

                    }

                    finally

                    {

                    }

                }

                result.StatusCode = StatusCodeType.Completed;

            }

            catch (Exception ex)

            {

                result.StatusCode = StatusCodeType.Error;

                result.Message =  LogHelper.GetStack() + " " +ex.Message;

            }

            return result;

        }

        public bool Stop()

        {

            try

            {

                gSaveTask.Dispose();

            }

            catch (Exception ex)

            {

                System.Diagnostics.Debug.WriteLine(ex.ToString());

            }

            return true;

        }

        /// <summary>

        /// 사용안함

        /// </summary>

        /// <param name="param"></param>

        /// <returns></returns>

        //[System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptions]

        //[System.Security.Permissions.FileIOPermission(System.Security.Permissions.SecurityAction.LinkDemand)]

        //private SaveResult SetFile()

        //{

        //    var saveitem = new SaveItem

        //    {

        //        Id = ConvertProcessContext.ConvertID,

        //        PdfFilePath = ConvertProcessContext.OriginFilePath,

        //        SavePath = ConvertProcessContext.SaveDirectory,

        //        Status = StatusCodeType.None

        //    };

        //    if (System.IO.Directory.Exists(saveitem.SavePath))

        //    {

        //        System.IO.Directory.Delete(saveitem.SavePath, true);

        //    }

        //    System.IO.Directory.CreateDirectory(saveitem.SavePath);

        //    try

        //    {

        //        Uri pdfFileUri = null;

        //        if (Uri.TryCreate(saveitem.PdfFilePath, UriKind.RelativeOrAbsolute, out pdfFileUri))

        //        {

        //            using (System.Net.WebClient webClient = new System.Net.WebClient())

        //            {

        //                webClient.UseDefaultCredentials = true;//.Headers.Add("Authorization: BASIC SGVsbG8="); //가상의 인증

        //                if (!System.IO.Directory.Exists(ConvertProcessContext.TempDirectory))

        //                {

        //                    System.IO.Directory.CreateDirectory(ConvertProcessContext.TempDirectory);

        //                }

        //                var downloadFilePath = System.IO.Path.Combine(ConvertProcessContext.TempDirectory, saveitem.Id.Replace("-", "") + ".pdf");

        //                webClient.DownloadFile(pdfFileUri, downloadFilePath);

        //                saveitem.PdfFilePath = downloadFilePath;

        //            }

        //        }

        //    }

        //    catch (Exception ex)

        //    {

        //        throw new Exception($"File Download Error  - File path : {saveitem.PdfFilePath}");

        //    }

        //    StationServiceClient.ConvertProcessStateAsync(saveitem.Id, (int)saveitem.Status, saveitem.CurrentPage, saveitem.TotalPages, saveitem.ErrorMessage);

        //    var result = gSaveTask.SaveFile(saveitem);

        //    return result;

        //}

    }

}