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 = 1073741824,

                    MultiThreadMaxPages = MultiThreadMaxPages,

                    MinFontSize = MinFontSize,

                    SendStatusInterval = SaveStatusInterval

                };

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

        {

            if (ServiceStation.AliveConvertQueue.Count() == 0)

            {

                /// 트랜젝션문제로 각각 선언하여 호출한다.

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

                {

                    database.SetCleanUpItems(RunProjectList);

                }

            }

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

            {

                var _items = database.GetWaitConvertItems(RunProjectList,ServiceStation.AliveConvertQueue, MultiProcessCount - ServiceStation.AliveConvertQueue.Count());

                if (_items.Count() > 0)

                {

                    foreach (var item in _items)

                    {

                        ConvertProcessStart(item);

                    }

                }

                else

                {

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

                }

            }

        }

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

            }

        }

    }

}