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;

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();

            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 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.FontNotFound:

                        break;

                    case StatusCodeType.NeedsPassword:

                        break;

                    case 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 PROCESS_TEST

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

#endif     

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

#if PROCESS_TEST

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

#endif

                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 }");

            }

            finally

            {

                this.Dispose();

            }

            // 플러그인 실행

#if PROCESS_TEST

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

#endif

            PluginService.Run(saveitem.Id);

            return saveitem;

        }

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

                //파일 다운로드

                if (DownloadFile(saveitem,out string downloadFilePath))

                {

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

                    if (gMarkusPDF.PageCount() > 0)

                    {

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

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

                        {

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

                            result = ConvertBigFileProcess(saveitem, downloadFilePath);

                        }

                        else

                        {

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

                            var task = new Task(new Action(() =>

                            {

                                result = gSaveTask.SaveFile(saveitem);

                            }), TaskCreationOptions.LongRunning);

                            task.Start();

                            task.Wait();

                        }

                        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, downloadFilePath);

                            }

                            ///  페이지 정보 저장

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

                            {

                                bool docSetResult = false;

                                try

                                {

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

                                    }

                                }

                                catch (Exception ex)

                                {

                                    result.Message += ex.ToString();

                                }

                                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 bool DownloadFile(SaveItem saveItem,out string DownloadFilePath)

        {

            bool result = false;

            string downloadFilePath = null;

            try

            {

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

            }

            catch (Exception ex)

            {

                logger.Error(ex);

                throw new Exception(ex.ToString());

            }

            DownloadFilePath = downloadFilePath;

            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(SaveItem saveitem,string downloadFilePath)

        {

            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)))

                        {

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

                            try

                            {

                                saveResult = gMarkusPDF.SavePage(currentPageNo, saveFile);

                            }

                            catch (Exception ex)

                            {

                                saveitem.ErrorMessage = LogHelper.GetStack() + " " + saveResult.Message + " " + ex.ToString();

                            }

                            if(saveResult.StatusCode == StatusCodeType.Completed)

                            {

                                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(downloadFilePath, saveitem.MinimumFontSize, saveitem.UseResolution, gFontsFolder);

                                }

                                System.Threading.Thread.SpinWait(2);

                            }

                            else

                            {

                                saveitem.Status = saveResult.StatusCode;

                                saveitem.CurrentPage = currentPageNo;

                                saveitem.ErrorMessage = saveResult.Message;

                                result.StatusCode = saveitem.Status;

                                result.Message = saveitem.ErrorMessage;

                                MarkusPdfStateChangeEvent(this, new StateEventArgs(saveitem));

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

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

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

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

                                Console.WriteLine($"last status code : {saveitem.Status}");

                                Console.WriteLine($"error message : {saveitem.ErrorMessage}");

                                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, saveitem.MinimumFontSize, saveitem.UseResolution, gFontsFolder);

                        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;

        //}

    }

}