MARKUS

using Markus.Message;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Management;

using static Markus.Service.Extensions.Encrypt;

using Markus.Service.Extensions;

using Markus.Service.Helper;

using Markus.Service.DataBase.Entities;

using Markus.Service.DataBase.Repositories;

namespace Markus.Service

{

    /// <summary>

    /// 컨버터 큐 처리 

    /// </summary>

    public partial class ServiceStation

    {

        /// <summary>

        /// 컨버터 실행중인 item

        /// </summary>

        private static List<ConvertDoc> AliveConvertQueue = new List<ConvertDoc>();

        /// <summary>

        /// 컨버터 프로세스 실행

        /// </summary>

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

        public bool ConvertProcessStart(ConvertDoc convertitem)

        {

            bool result = false;

            try

            {

                Process ConvertProcess = new Process();

                ProcessContext processSendData = new ProcessContext

                {

                    ConvertID = convertitem.ID,

                    ConnectionString = MarkusDBConnectionString,

                    ServiceStationUri = gServiceHostAddress.ToString(),

                    OriginFilePath = convertitem.DOCUMENT_URL,

                    SaveDirectory = convertitem.ConvertPath,

                    TempDirectory = DownloadTempFolder,

                    ReleaseWorkMemory = ReleaseWorkMemory,

                    MultiThreadMaxPages = MultiThreadMaxPages,

                    MinFontSize = MinFontSize,

                    SendStatusInterval = SaveStatusInterval,

                    UseResolution = UseResolution,

                    FontsFolder = FontsFolder

                };

                var sendData = ObjectToBytesStringConvert.ObjectToBytesString(processSendData);

                var convertPath = System.IO.Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "Convert\\Markus.Service.ConvertProcess.exe");

                ProcessStartInfo startInfo = new ProcessStartInfo

                {

                    UseShellExecute = false,

                    FileName = convertPath,

                    WindowStyle = ProcessWindowStyle.Hidden,

                    CreateNoWindow = true,

                    ErrorDialog = false,

                    RedirectStandardError = false,

                    Arguments = $"{convertitem.ID.ToString()} {AESEncrypter.Encrypt(sendData)}"

                    //Arguments = $"{convertitem.ConvertID.ToString()} {convertitem.ProjectNumber} {AESEncrypter.Encrypt(MarkusDBConnectionString)} {gServiceHostAddress} {DownloadTempFolder} {MultiThreadMaxPages}"

                };

                ConvertProcess.StartInfo = startInfo;

                ConvertProcess.EnableRaisingEvents = true;

                System.Diagnostics.Debug.WriteLine("convert process run : " + startInfo.Arguments);

                logger.Info($"convert process run : ConvertDoc ID:{convertitem.ID}" + startInfo.Arguments);

                if (ConvertProcess.Start())

                {

                    try

                    {

                        var processAffinity = ProcessorAffinityList.Except(AliveConvertQueue.Select(f => (long)f.ProcessorAffinity));

                        long currentAffinity = 0;

                        if (processAffinity.Count() > 0)

                        {

                            currentAffinity = processAffinity.First();

                            //int bitMask = 1 << (convertitem.ProcessorAffinity - 1);

                            //bitMask |= 1 << (anotherUserSelection - 1); / //  프로세스 두개 이상 선택

                            ConvertProcess.ProcessorAffinity = new IntPtr(currentAffinity);

                            logger.Info($"convert process currentAffinity set {currentAffinity} : ConvertDoc ID:{convertitem.ID}");

                        }

                        else

                        {

                            // 모두 사용중일때 점유율이 작은 걸로 사용

                            var CurrentProcessAffinity = AliveConvertQueue.Where(x=>x.ProcessorAffinity > 0).Select(f => f.ProcessorAffinity).Distinct();

                            currentAffinity = CurrentProcessAffinity.Min();

                            ConvertProcess.ProcessorAffinity = new IntPtr(currentAffinity);

                            logger.Info($"convert process Affinity All use {currentAffinity} :  ConvertDoc ID:{convertitem.ID}");

                        }

                        var item = AliveConvertQueue.Find(x => x.Equals(convertitem));

                        if (item != null)

                        {

                            item.ProcessorAffinity = currentAffinity;

                        }

                    }

                    catch (Exception ex)

                    {

                        AliveConvertQueue.Remove(convertitem);

                        logger.Error("ConvertProcessStart error", ex);

                    }

                    logger.Info($"convert process run true ConvertDoc ID:{convertitem.ID}");

                    result = true;

                }

            }

            catch (Exception ex)

            {

                AliveConvertQueue.Remove(convertitem);

                throw new Exception("ConvertThread " + $" ConvertDoc ID:{convertitem.ID} {convertitem.PROJECT_NO} {AESEncrypter.Encrypt(MarkusDBConnectionString)} {gServiceHostAddress} {DownloadTempFolder} {MultiThreadMaxPages}", ex.InnerException);

            }

            finally

            {

                //GC.WaitForPendingFinalizers();

                //GC.Collect(2);

                //GC.Collect(2);

            }

            return result;

        }

        /// <summary>

        /// DB에 있는 대기중인 Item을 가져온다.

        /// </summary>

        public void setDataBaseWaitingList()

        {

            using (ConvertDocRepository database = new ConvertDocRepository(MarkusDBConnectionString))

            {

                int totalProcessCount = this.ServiceProperty.PROCESS_COUNT + StationServiceList.Where(x => x.IsOnline).Sum(f => f.Properties.PROCESS_COUNT);

                var convertItems = database.GetWaitorErrorAsync(totalProcessCount).GetAwaiter().GetResult();

                foreach (var convert in convertItems)

                {

                    //ReflashSubService();

                    if (AliveConvertQueue.Count(x => x.ID == convert.ID || x.DOCUMENT_ID == convert.DOCUMENT_ID) == 0)

                    {

                        if (convert.STATUS > (int)StatusCodeType.None)

                        {

                            var result = database.SetCleanUpItemAsync(convert.ID, 1).GetAwaiter().GetResult();

                            if (result != 1)

                            {

                                throw new Exception($"SetCleanUpItem result :{result} {convert.ID}");

                            }

                        }

                        ConvertProcessAdd(convert.PROJECT_NO, convert.ID);

                        //PassConvertItem(convert.PROJECT_NO, convert.ID, convert.DOCUMENT_ID);

                        //System.Threading.Thread.Sleep(1000);

                    }

#if DEBUG

                    else

                    {

                        if (AliveConvertQueue.Count(x => x.ID == convert.ID) > 0)

                        {

                            if (System.Environment.UserInteractive)

                            {

                                Console.WriteLine($"AliveConvertQueue.Count(x => x.ID == convert.ID) : {convert.ID}");

                            }

                        }

                        if (AliveConvertQueue.Count(x=> x.DOCUMENT_ID == convert.DOCUMENT_ID) > 0)

                        {

                            if (System.Environment.UserInteractive)

                            {

                                Console.WriteLine($"AliveConvertQueue.Count(x.DOCUMENT_ID == convert.DOCUMENT_ID) : {convert.DOCUMENT_ID}");

                            }

                        }

                    }

#endif

                    /// 2022.11.28 수정

                    if (AliveConvertQueue.Count >= this.ServiceProperty.PROCESS_COUNT)

                    {

                        break;

                    }

                }

            }

        }

        /// <summary>

        /// DB에 있는 대기중인 Item을 가져온다.

        /// </summary>

        //public void setDataBaseWaitingLista()

        //{

        //    List<EntityModel.CONVERTER_DOC> convertItems = new List<EntityModel.CONVERTER_DOC>();

        //    using (DataBase.ConvertDatabase database = new DataBase.ConvertDatabase(MarkusDBConnectionString))

        //    {

        //        // 전체 서비스의 process count 만큼 waiting item을 가져온다.

        //        int totalProcessCount = this.ServiceProperty.PROCESS_COUNT + StationServiceList.Where(x => x.IsOnline).Sum(f => f.Properties.PROCESS_COUNT);

        //        convertItems = database.GetWaitConvertItems(this.RunProjectList, totalProcessCount).ToList();

        //    }

        //    foreach (var convert in convertItems)

        //    {

        //        //ReflashSubService();

        //        if (AliveConvertQueue.Count(x => x.ConvertID == convert.ID) == 0)

        //        {

        //            if (convert.STATUS > (int)StatusCodeType.None)

        //            {

        //                using (DataBase.ConvertDatabase database = new DataBase.ConvertDatabase(MarkusDBConnectionString))

        //                {

        //                    database.SetCleanUpItem(convert.ID, 1);

        //                }

        //            }

        //            ConvertProcessAdd(convert.PROJECT_NO, convert.ID);

        //            //PassConvertItem(convert.PROJECT_NO, convert.ID, convert.DOCUMENT_ID);

        //            //System.Threading.Thread.Sleep(1000);

        //        }

        //        /// 2022.11.28 수정

        //        if (AliveConvertQueue.Count >= this.ServiceProperty.PROCESS_COUNT)

        //        {

        //            break;

        //        }

        //    }

        //}

        public bool IsDataBaseWaitingList(int overListCount)

        {

            bool result = false;

            try

            {

                using (ConvertDocRepository convertDatabase = new ConvertDocRepository(MarkusDBConnectionString))

                {

                    var convertItems = convertDatabase.GetWaitorErrorAsync(overListCount).GetAwaiter().GetResult();

                    if (convertItems.Count() > 0)

                    {

                        result = true;

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"IsDataBaseWaitingList Error",ex);

            }

            return result;

        }

        private async Task<bool> ReflashSubServiceAsync()

        {

            bool result = false;

            try

            {

                foreach (var subservice in StationServiceList)

                {

                    try

                    {

                        subservice.IsOnline = await SytemNet.PingAsync(subservice.Properties.SERVICE_ADDRESS);

                        if (subservice.IsOnline)

                        {

                            var alivelist = await subservice.Service.AliveConvertListAsync();

                            subservice.ConvertItems = alivelist.Cast<ConvertDoc>().ToList();

                            subservice.AliveCount = alivelist.Count();

                        }

                        else

                        {

                            logger.Error($"Connection Error {subservice.Properties.SERVICE_ADDRESS}");

                            subservice.ConvertItems = new List<ConvertDoc>();

                            subservice.AliveCount = subservice.Properties.PROCESS_COUNT;

                        }

                        result = true;

                    }

                    catch (Exception ex)

                    {

                        logger.Error($"ReflashSubService error - Service ID : {subservice.Properties.ID} ", ex);

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"ReflashSubService error", ex);

            }

            return result;

        }

        /// <summary>

        /// 

        /// </summary>

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

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

        /// <param name="UniqueKey">Document ID(문서의 유일키)</param>

        private async void PassConvertItem(string ProjectNo,string ConvertDocID,bool isSubStation = false)

        {

            try

            {

                IEnumerable<SubStationServiceItem> stationList = null;

                //if (!isSubStation)

                //{

                    stationList = StationServiceList.Where(x => x.IsOnline);

                //}

                //else

                //{

                //    stationList = StationServiceList.Where(x => x.Properties.ID != this.ServiceID && x.IsOnline);

                //}

                if (stationList.SelectMany(x => x.ConvertItems).Count(c => c.PROJECT_NO == ProjectNo && c.ID == ConvertDocID) == 0)

                {

                    var station = stationList.OrderByDescending(x => x.Properties.PROCESS_COUNT - x.AliveCount).FirstOrDefault();

                    if (station != null)

                    {

                        if (station.Properties.PROCESS_COUNT - station.AliveCount > 0)

                        {

                            System.Diagnostics.Debug.WriteLine($"{station.Properties.SERVICE_ADDRESS}  {station.Properties.PROCESS_COUNT}/{station.AliveCount}");

                            var result = await station.Service.PassConvertAsync(ProjectNo, ConvertDocID);

                            if (!result.IsNullOrEmpty())

                            {

                                if (result.ToLower() == true.ToString().ToLower())

                                {

                                    Console.WriteLine($"PassConvertItem - Service ID : {station.Properties.ID} ConvertDocID : {ConvertDocID}");

                                    logger.Info($"PassConvertItem - Service ID : {station.Properties.ID} ConvertDocID : {ConvertDocID}");

                                    station.AliveCount++;

                                }

                                else

                                {

                                        logger.Error($"PassConvertItem Error result : {result} - Service ID : {station.Properties.ID} ConvertDocID : {ConvertDocID}");

                                }

                            }

                            else

                            {

                                logger.Error($"PassConvertItem result: Nulll; - Service ID : {station.Properties.ID} ConvertDocID : {ConvertDocID}");

                                System.Diagnostics.Debug.WriteLine("result : Nulll;");

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                logger.Error($"setDataBaseWaitingList", ex);

            }

        }

        /// <summary>

        /// 컨버터 프로세스와 AiliveItems을 비교하여 AliveItems에 없는 경우 AliveItems을 제거

        /// </summary>

        private void CleanUpAliveQueueItems()

        {

            if (AliveConvertQueue.Count() > 0)

            {

                var processList = Process.GetProcessesByName("Markus.Service.ConvertProcess");

                if (processList.Length == 0)

                {

                    AliveConvertQueue.Clear();

                    System.Diagnostics.Debug.WriteLine("AliveConvertQueue.Clear()");

                }

                else

                {

                    var argumentList = processList.Where(x=> !x.HasExited).Select(f => f.Arguments().CommandLine).SelectMany(f => f).ToList();

                    List<ConvertDoc> convertItems = AliveConvertQueue;

                    try

                    {

                        if (convertItems.Count() > 0 && argumentList.Count() > 0)

                        {

                            for (int i = convertItems.Count - 1; i >= 0; --i)

                            {

                                if (argumentList.Count(x => x == convertItems[i].ID) == 0)

                                {

                                    System.Diagnostics.Debug.WriteLine($"AliveConvertQueue remove {convertItems[i].ID}");

                                    logger.Warn($"AliveConvertQueue remove {convertItems[i].ID}");

                                    AliveConvertQueue.Remove(convertItems[i]);

                                }

                            }

                        }

                    }

                    catch (Exception ex)

                    {

                        logger.Error("CleanUpAliveQueueItems error",ex);

                    }

                }

            }

        }

        /// <summary>

        /// AliveConvertQueue와 db를 비교하여 AliveConvertQueue에 없는 데이터를 초기화 하여 다시 컨버팅

        /// </summary>

        private async void CleanUpDataBaseItems()

        {

            try

            {

                int totalProcessCount = this.ServiceProperty.PROCESS_COUNT + StationServiceList.Where(x => x.IsOnline).Sum(f => f.Properties.PROCESS_COUNT);

                using (DataBase.Repositories.ConvertDocRepository repository = new DataBase.Repositories.ConvertDocRepository(MarkusDBConnectionString))

                {

                    var items = repository.GetConvertingItemAsync(totalProcessCount).GetAwaiter().GetResult();

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

                    aliveItems.AddRange(this.AliveConvertList());

                    foreach (var item in StationServiceList.Where(x => x.IsOnline))

                    {

                        var serviceItems = await item.Service.AliveConvertListAsync();

                        aliveItems.AddRange(serviceItems.Cast<ConvertDoc>());

                    }

                    if (aliveItems.Count() > 0)

                    {

                        logger.Warn($"aliveItems  : {string.Join(",",aliveItems.Select(x=>x.ID))}");

                        foreach (var item in items)

                        {

                            if (aliveItems.Count(x => x.ID == item.ID) == 0)

                            {

                                Console.WriteLine($"SetCleanUpItem  : {item.ID}");

                                logger.Warn($"SetCleanUpItem  : {item.ID}");

                                repository.SetCleanUpItemAsync(item.ID, 0).GetAwaiter().GetResult();

                            }

                        }

                    }

                }

            }

            catch (Exception ex)

            {

                throw new Exception("CleanUpDataBaseItems Error ", ex);

            }

        }

        public void Stopprocess()

        {

            var process = Process.GetProcessesByName("Markus.Service.ConvertProcess");

            for (int i = process.Count() - 1; i >= 0 ; i--)

            {

                try

                {

                    Console.WriteLine($"{i} Process Kill");

                    process[i].Kill();

                }

                catch (Exception ex)

                {

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

                }

            }

        }

        /// <summary>

        /// finish가 호출되고 살아있는 프로세스라고 추정됨

        /// </summary>

        public void DeadLockProcessKill()

        {

            var process = Process.GetProcessesByName("Markus.Service.ConvertProcess");

            for (int i = process.Count() - 1; i >= 0; i--)

            {

                try

                {

                    var commandLines = process[i].Arguments().CommandLine;

                    if (commandLines.Count() > 0)

                    {

                        if (ServiceStation.AliveConvertQueue.Count(f => f.ID == commandLines[0]) == 0)

                        {

                            process[i].Kill();

                        }

                    }

                }

                catch (Exception ex)

                {

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

                }

            }

        }

        private async void ConvertFinish(ConvertDoc convertitem)

        {

            try

            {

                System.Diagnostics.Debug.WriteLine("Convert Finish : " + convertitem.ID);

                System.Diagnostics.Debug.WriteLine("ServiceStation.AliveConvertQueue.Count() : " + ServiceStation.AliveConvertQueue.Count());

                List<string> deleteItems = new List<string> { convertitem.ID };

                ServiceStation.AliveConvertQueue.RemoveAll(x=>deleteItems.Any(y=>y == x.ID));

                System.Diagnostics.Debug.WriteLine("ServiceStation.AliveConvertQueue.Count() : " + ServiceStation.AliveConvertQueue.Count());

                if (IsStation)

                {

                    if (!IsReleaseItems)

                    {

                        System.Diagnostics.Debug.WriteLine("ConvertFinish ReleaseItems call");

                        ReleaseItems();

                    }

                }

                else

                {

                    if (StationClient != null)

                    {

                       await  StationClient.ReleaseConvertItemsAsync();

                    }

                }

                //if (ServiceStation.AliveConvertQueue.Count() < MultiProcessCount)

                //{

                //    setDataBaseWaitingList();

                //}

            }

            catch (Exception ex)

            {

                logger.Error("ConvertFinish Error",ex);

            }

        }

    }

}