MARKUS

using log4net;

using Markus.Message;

using Markus.Service.Helper;

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 StatusCodeType = Markus.Message.StatusCodeType;

using Microsoft.SqlServer.Server;

using System.Web.UI;

using Markus.Service.DataBase.Entities;

using Markus.Service.DataBase.Repositories;

namespace Markus.Service.Convert

{

    public class ConvertService : IDisposable

    {

        // 1GigaBytes

        protected ILog logger;

        readonly ProcessContext ConvertProcessContext;

        private Markus.SaveTask gSaveTask;

        private Markus.MarkusPDF gMarkusPDF;

        private string gFontsFolder;

        private bool gIsApiDownload;

        // 컨버터 완료시 파일갯수를 체크 하여 틀리면 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 { TransferMode = TransferMode.Buffered };

            myBinding.CloseTimeout = new TimeSpan(0, 10, 0);

            myBinding.ReceiveTimeout = new TimeSpan(0, 10, 0);

            myBinding.SendTimeout = new TimeSpan(0, 10, 0);

            myBinding.OpenTimeout = new TimeSpan(0, 10, 0);

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

            StationServiceClient = new StationServiceClient(myBinding, myEndpoint);

            gIsApiDownload = ConvertProcessContext.IsApiDownload;

             gMarkusPDF = new MarkusPDF();

            gSaveTask = new SaveTask();

            if (!string.IsNullOrWhiteSpace(ConvertProcessContext.FontsFolder))

            {

                gFontsFolder = ConvertProcessContext.FontsFolder;

                gSaveTask.SetFontsFolder(ConvertProcessContext.FontsFolder);

            }

            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 Message.StatusCodeType.None:

                        break;

                    case Message.StatusCodeType.Wait:

                        break;

                    case Message.StatusCodeType.PageLoading:

                        break;

                    case Message.StatusCodeType.Saving:

                        break;

                    case Message.StatusCodeType.Completed:

                        break;

                    case Message.StatusCodeType.FileError:

                        break;

                    case Message.StatusCodeType.PageError:

                        break;

                    case Message.StatusCodeType.FontNotFound:

                        break;

                    case Message.StatusCodeType.NeedsPassword:

                        break;

                    case Message.StatusCodeType.Error:

                        break;

                    default:

                        break;

                }

#if PROCESS_TEST

                Console.WriteLine($"send wcf service {e.SaveItem.Status}  currentPage : {e.SaveItem.CurrentPage} error message : {(string.IsNullOrWhiteSpace(e.SaveItem.ErrorMessage)?"null":e.SaveItem.ErrorMessage)}");

#endif

                StationServiceClient.ConvertProcessState(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.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptions]

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

        public SaveItem SetFile()

        {

            SaveItem saveitem = new SaveItem

            {

                Id = ConvertProcessContext.ConvertID,

                PdfFilePath = ConvertProcessContext.OriginFilePath,

                SavePath = ConvertProcessContext.SaveDirectory,

                Status = StatusCodeType.None,

                MinimumFontSize = ConvertProcessContext.MinFontSize,

                UseResolution = ConvertProcessContext.UseResolution

            };

            try

            {

#if PROCESS_TEST

            Console.WriteLine($"ConvertID : {ConvertProcessContext.ConvertID} : {StatusCodeType.Wait.ToString()}");

#endif

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

                var result = Convert(saveitem);

                saveitem.Status = result.StatusCode;

                saveitem.ErrorMessage = result.Message;

                if (saveitem.Status < StatusCodeType.Completed)

                {

                    saveitem.Status = StatusCodeType.Error;

                    saveitem.ErrorMessage = "unknown error";

                }

                MarkusPdfStateChangeEvent(this, new StateEventArgs(new SaveItem

                {

                    ErrorMessage = saveitem.ErrorMessage,

                    Id = saveitem.Id,

                    CurrentPage = saveitem.CurrentPage,

                    TotalPages = saveitem.TotalPages,

                    Status = saveitem.Status

                }));

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

            }

            catch (Exception ex)

            {

                if (saveitem.Status <= StatusCodeType.Completed)

                {

                    saveitem.Status = StatusCodeType.Error;

                }

                saveitem.ErrorMessage = saveitem.ErrorMessage  + "    Exception : " +  ex.ToString();

                if( ex.InnerException != null)

                {

                    saveitem.ErrorMessage = saveitem.ErrorMessage + "  InnerException : " + ex.InnerException.ToString();

                }

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

                logger.Error($"saveitem.Id : {saveitem.Id} , StatusCode:{(int)saveitem.Status}, CurrentPage : {saveitem.CurrentPage}, TotalPages : {saveitem.TotalPages} , Error : {saveitem.ErrorMessage}");

                StationServiceClient.ConvertFinish(saveitem.Id, (int)saveitem.Status, saveitem.CurrentPage, saveitem.TotalPages, $"ConvertService Error    {saveitem.Id} {saveitem.ErrorMessage }");

            }

            try

            {

                // 플러그인 실행

#if PROCESS_TEST

                Console.WriteLine($"run Plugin : {saveitem.Id}");

#endif

                PluginService.Run(saveitem.Id);

#if PROCESS_TEST

                Console.WriteLine($"finish!!!");

#endif

            }

            catch (Exception ex)

            {

                throw;

            }

            return saveitem;

        }

        private bool MoveOldFiles(string originPath)

        {

            bool result = false;

            try

            {

                DirectoryInfo dir = new DirectoryInfo(originPath);

            }

            catch (Exception)

            {

            }

            return result;

        }

        private SaveResult Convert(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 ex)

                    {

#if PROCESS_TEST

                        Console.WriteLine(ex.ToString());

#endif

                    }

                    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;

#if PROCESS_TEST

                        Console.WriteLine($"{StatusCodeType.FileError.ToString()} : {result.Message} ");

#endif

                        return result;

                    }

                    System.Threading.Thread.SpinWait(10);

                }

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

                //파일 다운로드

                var fileDownloadResult = DownloadFile(saveitem);

                if (fileDownloadResult.IsSuccess)

                {

                    string downloadFilePath = fileDownloadResult.DownloadFilePath;

                    var status =  gMarkusPDF.pdfLoad(downloadFilePath, saveitem.MinimumFontSize, saveitem.UseResolution, gFontsFolder);

                    if (gMarkusPDF.PageCount() > 0)

                    {

                        saveitem.TotalPages = gMarkusPDF.PageCount();

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

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

                        {

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

                            result = ConvertBigFileProcess(saveitem.TotalPages, saveitem.Id, downloadFilePath,saveitem.SavePath, saveitem.MinimumFontSize,saveitem.UseResolution,gFontsFolder);

                        }

                        else

                        {

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

                            result = gSaveTask.SaveFile(new Markus.Message.SaveItem

                            {

                                PdfFilePath = downloadFilePath,

                                SavePath = saveitem.SavePath,

                                MinimumFontSize = saveitem.MinimumFontSize,

                                UseResolution = saveitem.UseResolution

                            });

                        }

                        saveitem.Status = result.StatusCode;

                        saveitem.ErrorMessage = result.Message;

                        if ((int)result.StatusCode <= (int)StatusCodeType.Completed)

                        {

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

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

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

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

                            {

                                ///statuscode가 완료 또는 정상인데 페이지가 맞지 않는 경우 pageError로 처리

                                if (result.StatusCode <= StatusCodeType.Completed)

                                {

                                    result.StatusCode = StatusCodeType.PageError;

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

                                }

                                ReConvert = 1;

                                result = ConvertBigFileProcess(saveitem.TotalPages, saveitem.Id, downloadFilePath, saveitem.SavePath, saveitem.MinimumFontSize, saveitem.UseResolution, gFontsFolder);

                                saveitem.Status = result.StatusCode;

                                saveitem.ErrorMessage = result.Message;

                            }

                            ///  페이지 정보 저장

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

                            {

                                bool docSetResult = false;

                                try

                                {

                                    using (DOCINFORepository dOCINFORepository = new DOCINFORepository(ConvertProcessContext.ConnectionString))

                                    {

                                        var docinfoId = dOCINFORepository.CreateAsync(convertDocID: saveitem.Id, PageCount: result.PageInfoList.Count()).GetAwaiter().GetResult();

                                        using (DOCPAGERepository database = new DOCPAGERepository(ConvertProcessContext.ConnectionString))

                                        {

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

                                            {

                                                DOCINFO_ID = docinfoId,

                                                PAGE_ANGLE = 0,

                                                PAGE_WIDTH = f.Width.ToString(),

                                                PAGE_HEIGHT = f.Height.ToString(),

                                                PAGE_NUMBER = f.PageNo

                                            });

                                            docSetResult = database.CreateAsync(docPageList).GetAwaiter().GetResult();

                                        }

                                    }

                                    saveitem.CurrentPage = result.PageInfoList.Max(x => x.PageNo);

                                }

                                catch (Exception ex)

                                {

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

                                }

                                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 = $"{status.Message}. File path : { saveitem.PdfFilePath}";

                        result.StatusCode = status.StatusCode;

                    }

                }

                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

            {

                if (gMarkusPDF != null)

                {

                    gMarkusPDF.Dispose();

                    gMarkusPDF = null;

                }

            }

            return result;

        }

        public FileDownloadResult DownloadFile(SaveItem saveItem)

        {

            FileDownloadResult result = new FileDownloadResult();

            try

            {

                result = DownloadPluginService.Download(saveItem.PdfFilePath, saveItem.SavePath);

            }

            catch (Exception ex)

            {

                logger.Error(ex);

                result.IsSuccess = false;

                result.Exception = new Exception(ex.ToString());

            }

            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

        //            {

        //                if (gIsApiDownload)

        //                {

        //                    ///read api download 

        //                    ///벽산

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

        //                }

        //                else

        //                {

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

        //                        webClient.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();

        //    }

        //    return downloadFilePath;

        //}

        /// <summary>

        /// 큰파일 변환

        /// </summary>

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

        /// <returns></returns>

        private SaveResult ConvertBigFileProcess(int totalPages,string convertId, string downloadFilePath, string savePath, int minimumFontSize,int useResolution,string fontsFolder)

        {

            SaveResult result = new SaveResult();

            try

            {

                for (int currentPageNo = 1; currentPageNo <= totalPages; currentPageNo++)

                {

                    try

                    {

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

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

                        {

                            SaveResult saveResult = new SaveResult { StatusCode = StatusCodeType.None };

                            StatusCodeType stateCode = StatusCodeType.Saving;

                            try

                            {

                                saveResult = gMarkusPDF.SavePage(currentPageNo, saveFile);

                            }

                            catch (Exception ex)

                            {

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

                            }

                            result.StatusCode = saveResult.StatusCode;

                            if (result.StatusCode != StatusCodeType.Completed)

                            {

                                stateCode = result.StatusCode;

                            }

                            MarkusPdfStateChangeEvent(this, new StateEventArgs(new SaveItem

                            {

                                ErrorMessage = result.Message,

                                Id = convertId,

                                CurrentPage = currentPageNo,

                                TotalPages = totalPages,

                                Status = stateCode

                            }));

                            if (saveResult.StatusCode == StatusCodeType.Completed)

                            {

                                result.PageInfoAdd(saveResult.SavePageInfo);

                                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(downloadFilePath,minimumFontSize,useResolution, fontsFolder);

                                }

                                System.Threading.Thread.SpinWait(2);

                            }

                            else

                            {

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

                                Console.WriteLine($"convert ID : {convertId}");

                                Console.WriteLine($"pdf file Path : {downloadFilePath}");

                                Console.WriteLine($"save file path : {savePath}");

                                Console.WriteLine($"last status code : {result.StatusCode}");

                                Console.WriteLine($"error message : {result.Message}");

                                break;

                            }

                        }

                    }

                    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(downloadFilePath, minimumFontSize, useResolution, fontsFolder);

                        currentPageNo = currentPageNo - 1;

                    }

                    finally

                    {

                    }

                }

            }

            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;

        //}

    }

}