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

        {

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

            {

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

                foreach (var convert in convertItems)

                {

                    //ReflashSubService();

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

                    {

                        database.SetCleanUpItem(convert.ID);

                    }

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

        {

            foreach (var subservice in StationServiceList)

            {

                try

                {

                    subservice.IsOnline = SytemNet.Ping(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)

                    {

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

                        var result = await station.Service.ConvertAddAsync(ProjectNo, ConvertID);

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

                        {

                            station.AliveCount++;

                        }

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

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

                    {

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

                        {

                            AliveConvertQueue.RemoveAt(i);

                        }

                    }

                }

            }

        }

        /// <summary>

        /// 데이터베이스에서 멈춰있거나 

        /// </summary>

        private async void CleanUpDataBaseItems()

        {

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

                {

                    try

                    {

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

                        aliveItems.AddRange(serviceItems);

                    }

                    catch (Exception)

                    {

                    }

                }

                foreach (var item in items)

                {

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

                    {

                        database.SetCleanUpItem(item.ID);

                    }

                }

            }

        }

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

                    {

                        StationClient.ReleaseConvertItems();

                    }

                }

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

                //{

                //    setDataBaseWaitingList();

                //}

            }

            catch (Exception ex)

            {

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

            }

        }

    }

}