MARKUS

using Markus.Service.Interface;

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;

namespace Markus.Service

{

    /// <summary>

    /// 컨버터 큐 처리 

    /// </summary>

    public partial class ServiceStation

    {

        /// <summary>

        /// 컨버터 실행중인 item

        /// </summary>

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

        /// <summary>

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

        /// </summary>

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

        public bool ConvertProcessStart(ConvertItem convertitem)

        {

            bool result = false;

            try

            {

                Process ConvertProcess = new Process();

                ProcessContext processSendData = new ProcessContext

                {

                    ConvertID = convertitem.ConvertID,

                    ConnectionString = MarkusDBConnectionString,

                    ServiceStationUri = gServiceHostAddress.ToString(),

                    OriginFilePath = convertitem.OriginfilePath,

                    SaveDirectory = convertitem.ConvertPath,

                    TempDirectory = DownloadTempFolder,

                    ReleaseWorkMemory = ReleaseWorkMemory,

                    MultiThreadMaxPages = MultiThreadMaxPages,

                    MinFontSize = MinFontSize,

                    SendStatusInterval = SaveStatusInterval,

                    UseResolution = UseResolution

                };

                var sendData = ObjectToBytesStringConvert.ObjectToBytesString(processSendData);

                ProcessStartInfo startInfo = new ProcessStartInfo

                {

                    UseShellExecute = false,

                    FileName = "Markus.Service.ConvertProcess.exe",

                    WindowStyle = ProcessWindowStyle.Hidden,

                    CreateNoWindow = true,

                    ErrorDialog = false,

                    RedirectStandardError = false,

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

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

                };

                ConvertProcess.StartInfo = startInfo;

                ConvertProcess.EnableRaisingEvents = false;

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

                if (ConvertProcess.Start())

                {

                    try

                    {

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

                        if (processAffinity.Count() > 0)

                        {

                            convertitem.ProcessorAffinity = processAffinity.First();

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

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

                            ConvertProcess.ProcessorAffinity = new IntPtr(convertitem.ProcessorAffinity);

                        }

                        else

                        {

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

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

                            var affinity = CurrentProcessAffinity.Min();

                            convertitem.ProcessorAffinity = affinity;

                            ConvertProcess.ProcessorAffinity = new IntPtr(affinity);

                        }

                    }

                    catch (Exception ex)

                    {

                        System.Diagnostics.Debug.WriteLine(ex);

                    }

                    ServiceStation.AliveConvertQueue.Add(convertitem);

                    result = true;

                }

            }

            catch (Exception ex)

            {

                throw new Exception("ConvertThread " + $"{convertitem.ConvertID.ToString()} {convertitem.ProjectNumber} {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()

        {

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

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

            {

                convertItems = database.GetWaitConvertItems(this.RunProjectList, StationServiceList.Where(x=>x.IsOnline).Sum(f=>f.Properties.PROCESS_COUNT)).ToList();

            }

            foreach (var convert in convertItems)

            {

                //ReflashSubService();

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

                {

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

                    {

                        database.SetCleanUpItem(convert.ID,1);

                    }

                }

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

            }

        }

        public bool IsDataBaseWaitingList(int overListCount)

        {

            bool result = false;

            try

            {

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

                {

                    var convertItems = database.GetWaitConvertItems(this.RunProjectList, overListCount);

                    if (convertItems.Count() > 0)

                    {

                        result = true;

                    }

                }

            }

            catch (Exception ex)

            {

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

            }

            return result;

        }

        private async void ReflashSubServiceAsync()

        {

            foreach (var subservice in StationServiceList)

            {

                try

                {

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

                    if (subservice.IsOnline)

                    {

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

                        subservice.ConvertItems = result.ToList();

                        subservice.AliveCount = result.Count();

                    }

                    else

                    {

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

                        subservice.ConvertItems = new List<WcfClient.StationServiceTask.ConvertItem>();

                        subservice.AliveCount = subservice.Properties.PROCESS_COUNT;

                    }

                }

                catch (Exception ex)

                {

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

                }

            }

        }

        /// <summary>

        /// 

        /// </summary>

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

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

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

        private async void PassConvertItem(string ProjectNo,string ConvertID,string UniqueKey)

        {

            try

            {

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

                if (stationList.SelectMany(x => x.ConvertItems).Count(c => c.ProjectNumber == ProjectNo && c.UniqueKey == UniqueKey) == 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.ConvertAddAsync(ProjectNo, ConvertID);

                            if (!result.IsNullOrEmpty())

                            {

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

                                {

                                    station.AliveCount++;

                                }

                            }

                            else

                            {

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

                            }

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

                        }

                    }

                }

            }

            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.Select(f => f.Arguments().CommandLine).SelectMany(f => f);

                    List<ConvertItem> convertItems = AliveConvertQueue;

                    try

                    {

                        if (convertItems.Count() > 0)

                        {

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

                            {

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

                                {

                                    AliveConvertQueue.RemoveAt(i);

                                }

                            }

                        }

                    }

                    catch (Exception ex)

                    {

                        System.Diagnostics.Debug.WriteLine(ex);

                    }

                }

            }

        }

        /// <summary>

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

        /// </summary>

        private async void CleanUpDataBaseItems()

        {

            try

            {

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

                {

                    var items = database.GetConvertingItems(RunProjectList);

                    List< WcfClient.StationServiceTask.ConvertItem> aliveItems = new List<WcfClient.StationServiceTask.ConvertItem>();

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

                    {

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

                        aliveItems.AddRange(serviceItems);

                    }

                    foreach (var item in items)

                    {

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

                        {

                            database.SetCleanUpItem(item.ID,0);

                        }

                    }

                }

            }

            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.ConvertID == commandLines[0]) == 0)

                        {

                            process[i].Kill();

                        }

                    }

                }

                catch (Exception ex)

                {

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

                }

            }

        }

        private async void ConvertFinish(ConvertItem convertitem)

        {

            try

            {

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

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

                ServiceStation.AliveConvertQueue.Remove(convertitem);

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

            }

        }

    }

}