MARKUS

using Markus.Message;

using Markus;

using Markus.Service.DataBase;

using Markus.Service.DataBase.Repositories;

using Markus.Service.Extensions;

using Markus.Service.IWcfService;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.ServiceModel;

using System.ServiceModel.Activation;

using System.ServiceModel.Web;

using System.Text;

using System.Threading.Tasks;

using Markus.Service.DataBase.Entities;

namespace Markus.Service

{

    /// <summary>

    /// web service 목록

    /// </summary>

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

    //[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, IncludeExceptionDetailInFaults = true)]

    public partial class ServiceStation : IStationService

    {

        /// <summary>

        /// DB에 Convrert Item을 추가 하고 호출 

        /// CovnertWebService에서 호출시 사용

        /// </summary>

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

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

        /// <returns></returns>

        public string ConvertAdd(string ProjectNo, string ConvertID)

        {

            string result = false.ToString();

            try

            {

                result = ConvertProcessAdd(ProjectNo, ConvertID);

                logger.Info($"ConvertAdd Call Item ProjectNo : {ProjectNo}  ConvertID : {ConvertID}  result : {result}");

            }

            catch (Exception ex)

            {

                result = $"ConvertAdd Error {ConvertID}";

                logger.Error($"ConvertAdd Error- {ConvertID}", ex);

            }

            return result;

        }

        /// <summary>

        /// Main Station에서 전달받은 convert item

        /// </summary>

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

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

        /// <returns></returns>

        public string PassConvert(string ProjectNo, string ConvertDocID)

        {

            string result = false.ToString();

            try

            {

                using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

                {

                    var convertItem = database.GetConvertDocSingleAsync(ProjectNo:ProjectNo,ConvertID:ConvertDocID).GetAwaiter().GetResult();

                    /// 순서별 Convert Item 처리 

                    if (convertItem != null)

                    {

                        if (AliveConvertQueue.Count(c => c.ID == convertItem.ID) == 0)

                        {

                            result = ConvertProcessAdd(ProjectNo, ConvertDocID);

                            logger.Info($"PassConvert Item ProjectNo : {ProjectNo}  ConvertDocID : {ConvertDocID}  result : {result}");

                        }

                        else

                        {

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                result = $"PassConvert Error {ConvertDocID}";

                logger.Error($"PassConvert Error- {ConvertDocID}", ex);

            }

            return result;

        }

        /// <summary>

        /// 별도의 호출 사용 

        /// </summary>

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

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

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

        /// <returns></returns>

        public string ConvertMenualAdd(string ProjectNo, string originfilePath, string DocumentID)

        {

            string result = false.ToString();

            try

            {

                using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

                {

                    //var convertItem = database.GetConvertDocSingleAsync(ProjectNo: ProjectNo, DocumentID: DocumentID).GetAwaiter().GetResult();

                    //if (convertItem != null)

                    //{

                    var newConvertDocId = database.CreateAsync(ProjectNo, originfilePath, DocumentID).GetAwaiter().GetResult();

                    if (newConvertDocId == null)

                    {

                        logger.Error($"Set Convert document Insert Error - createId is Null. ProjectNo:{ProjectNo} originfilePath:{originfilePath} DocumentID:{DocumentID}");

                    }

                    else

                    {

                        var aliveItems = AliveConvertQueue.Where(x => x.DOCUMENT_ID == DocumentID);

                        if (aliveItems.Count() == 0)

                        {

                            result = ConvertProcessAdd(ProjectNo, newConvertDocId);

                        }

                        else

                        {

                            logger.Info("ConvertMenualAdd Wait ProjectNo:{ ProjectNo} originfilePath: { originfilePath} DocumentID: { DocumentID}");

                        }

                        result = true.ToString();

                    }

                    //}

                }

            }

            catch (Exception ex)

            {

                result = "ConvertMenualAdd Error";

                logger.Error($"ConvertMenualAdd Error-  database.SetConvertDoc ProjectNo:{ProjectNo} originfilePath:{originfilePath} DocumentID:{DocumentID}", ex);

            }

            return result;

        }

        /// <summary>

        /// ConvertItem의 상태

        /// </summary>

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

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

        /// <returns></returns>

        public Item GetConvertItem(string ProjectNo, string DocumentID)

        {

            Item result = null;

            try

            {

                using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

                {

                    var convertItem = database.GetConvertDocSingleAsync(ProjectNo: ProjectNo, DocumentID: DocumentID).GetAwaiter().GetResult();

                    if (convertItem != null)

                    {

                        string baseStoragePath = null;

                        using(PROPERTIESRepository repository = new PROPERTIESRepository(MarkusDBConnectionString))

                        {

                            var propeties = repository.GetFirstAsync(ProjectNo, PropertiesTypeDefine.TILE_SOURCE_STORAGE).GetAwaiter().GetResult();

                            if(propeties != null)

                            {

                                baseStoragePath = propeties.VALUE;

                            }

                            else

                            {

                                throw new FaultException($"Get {ProjectNo} is {PropertiesTypeDefine.TILE_SOURCE_STORAGE} null Error");

                            }

                        }

                        var convertPath = CreateConvertPath.Get(baseStoragePath, ProjectNo, DocumentID);

                        result =

                        new Item

                        {

                            DocumentID = convertItem.ID,

                            Status = convertItem.STATUS.ToString(),

                            ProjectNo = convertItem.PROJECT_NO,

                            TotalPage = convertItem.TOTAL_PAGE,

                            CurrentPageNo = convertItem.CURRENT_PAGE,

                            PdfPath = convertItem.DOCUMENT_URL,

                            ConvertPath = convertPath

                        };

                    }

                }

            }

            catch (Exception ex)

            {

                throw new FaultException("Get ConvertItem Error");

            }

            return result;

        }

        /// <summary>

        /// Convert Item을 DB에 추가 하고 프로세스 실행시 호출

        /// </summary>

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

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

        /// <returns></returns>

        private string ConvertProcessAdd(string ProjectNo, string convertID)

        {

            string result = false.ToString();

            logger.Warn($"WCF ConvertProcessAdd Call ProjectNo:{ProjectNo} convertID:{convertID} ");

            using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

            {

                var convertItem = database.GetConvertDocSingleAsync(ProjectNo:ProjectNo,ConvertID:convertID).GetAwaiter().GetResult();

                /// 순서별 Convert Item 처리 

                if (convertItem != null)

                {

                    try

                    {

                        if (AliveConvertQueue.Find(c => c.ID == convertItem.ID) == null)

                        {

                            if (AliveConvertQueue.Count() < ServiceProperty.PROCESS_COUNT)

                            {

                                convertItem.SERVICE_ID = this.ServiceID;

                                AliveConvertQueue.Add(convertItem);

                                var startResult = ConvertProcessStart(convertItem);

                                if(!startResult)

                                {

                                    AliveConvertQueue.Remove(convertItem);

                                }

                                result = true.ToString();

                            }

                            else

                            {

                                logger.Warn($"ConvertProcessAdd  PassConvertItem ProcessCount ProjectNo:{ProjectNo} convertID:{convertID} ");

                                /// sub service (다른ip의 서비스로 보낸다) 이중화

                                PassConvertItem(ProjectNo, convertID, true);

                                result = true.ToString();

                            }

                        }

                        else

                        {

                            result = true.ToString();

                        }

                    }

                    catch (Exception ex)

                    {

                        result = "Convert Process Start Error";

                        logger.Error($"ConvertAdd  ConvertProcess call Error  ProjectNo:{ProjectNo} convertID:{convertID} ", ex);

                    }

                }

                else

                {

                    logger.Error($"ConvertAdd  ConvertProcess call Error  ProjectNo:{ProjectNo} convertID:{convertID} item Null ");

                    result = "Get ConvertItem Error";

                }

            }

            return result;

        }

        /// <summary>

        /// 각 ConvertProcess의 상태값을 저장

        /// </summary>

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

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

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

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

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

        /// <returns></returns>

        public bool ConvertProcessState(string ConvertDocID, int status, int CurrentPage, int TotalPage, string Error)

        {

            bool isStatusChange = false;

            if (AliveConvertQueue.Count() > 0)

            {

                var items = AliveConvertQueue.Where(x => x.ID == ConvertDocID);

                if (items.Count() > 0)

                {

                    var item = items.First();

                    item.TOTAL_PAGE = TotalPage;

                    item.CURRENT_PAGE = CurrentPage;

                    if (item.STATUS != status)

                    {

                        item.STATUS = status;

                        isStatusChange = true;

                    }

                }

            }

            if (isStatusChange || CurrentPage % SaveStatusInterval == 0 || !Error.IsNullOrEmpty())

            {

                using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

                {

                    var result = database.UpdateStatusAsync(this.ServiceID, ConvertDocID, status, CurrentPage, TotalPage, Error).GetAwaiter().GetResult();

                    if (result < 1)

                    {

                        logger.Error($"DataBase Error database.SetConvertState({ConvertDocID}, {(int)status},{CurrentPage},{TotalPage}, {Error})");

                    }

                }

            }

            return true;

        }

        /// <summary>

        /// Convert Process 완료시 호출

        /// </summary>

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

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

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

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

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

        /// <returns></returns>

        public bool ConvertFinish(string ConvertDocID, int status, int CurrentPage, int TotalPage, string Error)

        {

            using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

            {

                var result = database.UpdateStatusAsync(this.ServiceID, ConvertDocID, status, CurrentPage, TotalPage, Error).GetAwaiter().GetResult();

                if (result < 1)

                {

                    logger.Error($"DataBase Error database.SetConvertState({ConvertDocID}, {(int)status},{CurrentPage},{TotalPage}, {Error})");

                }

            }

            var _convertItem = AliveConvertQueue.Where(f => f.ID == ConvertDocID);

            if (_convertItem.Count() > 0)

            {

                ConvertFinish(_convertItem.First());

            }

            return true;

        }

        /// <summary>

        /// 대기중인 Convert Item을 가져옴

        /// </summary>

        /// <returns></returns>

        public List<ConvertDoc> WaitConvertList()

        {

            List<ConvertDoc> result = new List<ConvertDoc>();

            using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

            {

                result = database.GetConvertDocAsync((int)Message.StatusCodeType.Wait).GetAwaiter().GetResult().ToList();

            }

            return result;

        }

        /// <summary>

        /// 현재 AliveConvertQueue에 있는 컨버터 리스트

        /// </summary>

        /// <returns></returns>

        public List<ConvertDoc> AliveConvertList()

        {

            return ServiceStation.AliveConvertQueue;

        }

        /// <summary>

        /// WCF 시작

        /// </summary>

        /// <returns></returns>

        public CommunicationState StartWcfService()

        {

            CommunicationState result = CommunicationState.Faulted;

            try

            {

                if (gServiceHostAddress != null)

                {

                    gWcfServiceHost = gWcfServiceHost.WcfCreate(this, typeof(IWcfService.IStationService), gServiceHostAddress);

                }

                if (gWcfServiceHost?.State != CommunicationState.Faulted)

                {

                    result = gWcfServiceHost.State;

                }

            }

            catch (Exception ex)

            {

                logger.Error("Start WCF Service Error ", ex);

            }

            return result;

        }

        /// <summary>

        /// WCF 중단

        /// </summary>

        /// <returns></returns>

        private bool StopWcfService()

        {

            bool result = false;

            try

            {

                if (gWcfServiceHost != null)

                {

                    gWcfServiceHost.Abort();

                }

                result = true;

            }

            catch (Exception ex)

            {

                logger.Error("Stop WCF Service Error ", ex);

            }

            return result;

        }

        public bool ReleaseConvertItems()

        {

            System.Diagnostics.Debug.WriteLine("Call ReleaseConvertItems");

            if (!IsReleaseItems)

            {

                ReleaseItems();

            }

            System.Diagnostics.Debug.WriteLine("end ReleaseConvertItems");

            return true;

        }

    }

}