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.Sum(f=>f.Properties.PROCESS_COUNT));

                foreach (var convert in convertItems)

                {

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

                    {

                        database.SetCleanUpItem(convert.ID);

                    }

                    PassConvertItem(convert.PROJECT_NO, convert.ID);

                }

            }

        }

        private void ReflashSubService()

        {

            foreach (var subservice in StationServiceList)

            {

                try

                {

                    var result = subservice.Service.AliveConvertList();

                    subservice.ConvertItems = result.ToList();

                    subservice.AliveCount = result.Count();

                }

                catch (Exception ex)

                {

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

                }

            }

        }

        private void PassConvertItem(string ProjectNo,string ConvertID)

        {

            ReflashSubService();

            try

            {

                if (StationServiceList.SelectMany(x => x.ConvertItems).Count(c => c.ProjectNumber == ProjectNo && c.ConvertID == ConvertID) == 0)

                {

                    var station = StationServiceList.OrderBy(x => x.AliveCount).FirstOrDefault();

                    if (station != null)

                    {

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

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

                    }

                }

            }

            catch (Exception ex)

            {

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

            }

        }

        private void CleanUpItems()

        {

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

            {

                var items = database.GetConvertingItems(RunProjectList);

                List<StationService.ConvertItem> aliveItems = new List<StationService.ConvertItem>();

                foreach (var item in StationServiceList)

                {

                    try

                    {

                        aliveItems.AddRange(item.Service.AliveConvertList());

                    }

                    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 (ServiceStation.AliveConvertQueue.Count() < MultiProcessCount)

                //{

                //    setDataBaseWaitingList();

                //}

            }

            catch (Exception ex)

            {

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

            }

        }

    }

}