MARKUS

using log4net;

using Markus.Service.Extensions;

using Markus.Service.Helper;

using Markus.Service.IWcfService;

using Markus.Service.WcfService;

using Salaros.Configuration;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Diagnostics;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.ServiceModel;

using System.ServiceProcess;

using System.Text;

using System.Threading.Tasks;

using System.Timers;

using static Markus.Service.Extensions.Encrypt;

namespace Markus.Service

{

    public partial class ServiceStation : ServiceBase

    {

        protected ILog logger = LogManager.GetLogger(typeof(ServiceStation));

        protected ServiceHost gWcfServiceHost;

        System.Timers.Timer timer;

        private int MultiProcessCount = 1;

        private string ServiceID;

        private List<SubStationServiceItem> StationServiceList;

        private List<string> StationServiceIDList;

        private Service.WcfClient.StationServiceAsync.StationServiceClient StationClient;

        private bool IsStation;

        private Uri gServiceHostAddress;

        private string MarkusDBConnectionString;

        private string DownloadTempFolder;

        private int MultiThreadMaxPages;

        private int MinFontSize;

        private int UseResolution;

        private bool CreateProcessWindow;

        private long ReleaseWorkMemory;

        private int SaveStatusInterval;

        private static bool IsReleaseItems;

        private List<string> RunProjectList = new List<string>();

        /// <summary>

        /// 프로세스 카운터 자주 람다식을 사용해서 list<int>로 함.

        /// </summary>

        private List<Int64> ProcessorAffinityList;

        private string configFileName;

        public ServiceStation()

        {

            InitializeComponent();

        }

        /// <summary>

        /// Config 파일 

        /// </summary>

        public void GetApplicationConfig()

        {

            try

            {

                ConfigParser config = null;

                try

                {

                    configFileName = $"{typeof(ServiceStation).Name}.ini";

                    config = ConfigHelper.AppConfig(this.configFileName);

                }

                catch (Exception)

                {

                    throw new Exception("Config Read Error.");

                }

                if (config != null)

                {

                    // CONVERT DATABASE 연결 문자열

                    MarkusDBConnectionString = AESEncrypter.Decrypt(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.MARKUS_CONNECTION_STRING));

                    IsStation = System.Convert.ToBoolean(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.IS_STATAION, "false"));

                    ServiceID = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.SERVICE_ID, Guid.Empty.ToString());

                    if (IsStation)

                    {

                        var servicetList = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.SERVICE_LIST, "");

                        if (!servicetList.IsNullOrEmpty())

                        {

                            StationServiceIDList = servicetList.Split(',').ToList();

                        }

                    }

                    else

                    {

                        var address = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.STATAION_ADDRESS,"");

                        if (!address.IsNullOrEmpty())

                        {

                            BasicHttpBinding myBinding = new BasicHttpBinding();

                            EndpointAddress myEndpoint = new EndpointAddress(UriHelper.UriCreate(address));

                            StationClient = new WcfClient.StationServiceAsync.StationServiceClient(myBinding, myEndpoint);

                        }

                    }

                    MultiProcessCount = System.Convert.ToInt16(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.CONVERT_SERVICE_PROCESS,"5"));

                    CreateProcessWindow = System.Convert.ToBoolean(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.CREATE_WINDOW, "false"));

                    // PDF 임시 다운로드 폴더

                    DownloadTempFolder = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.DOWNLOAD_TEMP_FOLDER,"C:\\temp");

                    MultiThreadMaxPages = System.Convert.ToInt16(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.MULTI_TRHEAD_MAX_PAGE, "500"));

                    SaveStatusInterval = System.Convert.ToInt16(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.SAVE_STATUS_INTERVAL, "5"));

                    MinFontSize = System.Convert.ToInt16(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.MIN_FONT_SIZE, "10"));

                    UseResolution = System.Convert.ToInt16(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.USE_RESOLUTION, "0"));

                    var workingMemory = System.Convert.ToDouble(config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.RELEASE_WORK_MEMORY, "1.5"));

                    ReleaseWorkMemory = MathBytes.Bytes(workingMemory, DataSizeType.GB);

                    var projectList = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.FITER_PROCECT,"");

                    if(!projectList.IsNullOrEmpty())

                    {

                        RunProjectList = projectList.Split(',').ToList();

                    }

                    // 서비스 ENDPOINT

                    // http://localhost/

                    var endpointName = config.GetValue(CONFIG_DEFINE.WCF_ENDPOINT, CONFIG_DEFINE.STATION_SERVICE_NAME);

                    var port = config.GetValue(CONFIG_DEFINE.WCF_ENDPOINT, CONFIG_DEFINE.STATION_PORT);

                    if (!string.IsNullOrWhiteSpace(endpointName) && port.IsNumber())

                    {

                        gServiceHostAddress = UriHelper.UriCreate($"http://localhost:{port}/{endpointName}");

                    }

                }

            }

            catch (Exception ex)

            {

                throw new Exception("ApplicationConfig ", ex);

            }

        }

        protected override void OnStart(string[] args)

        {

            try

            {

                StartService();

            }

            catch (Exception ex)

            {

                logger.Error("ServiceStation Start Error - ", ex);

            }

        }

        private void Timer_Elapsed(object sender, ElapsedEventArgs e)

        {

            timer.Stop();

            if (!IsReleaseItems)

            {

                ReleaseItems();

            }

            System.Threading.Thread.SpinWait(10000);

            timer.Start();

        }

        /// <summary>

        /// alivequeue와 process를 비교하여 정리하고

        /// 대기중인 아이템을 분배한다.

        /// </summary>

        private void ReleaseItems()

        {

            try

            {

                IsReleaseItems = true;

                CleanUpAliveQueueItems();

                if (IsStation)

                {

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

                    ReflashSubService();

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

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

                    CleanUpDataBaseItems();

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

                    setDataBaseWaitingList();

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

                }

            }

            catch (Exception ex)

            {

                logger.Error("get Wating Item error", ex);

            }

            IsReleaseItems = false;

        }

        /// <summary>

        /// System.Diagnostics.Process의 ProcessorAffinity Core 선호도를 위한 초기화

        /// 설정된 MultiProcessCount에 대해서 프로세스의 코어의 선호도를 지정 한다.

        /// 코어의 선택은 비트로 이루어 진다.

        /// 8코어에서 1번 코어 00000001

        /// 8코어에서 1번 3번 코어 00000101

        /// 8코어에서 1번 3번 코어 00000101

        /// 8코어에서 1,2,3 선택   00000111

        /// https://dotnetgalactics.wordpress.com/2009/10/20/how-to-set-the-processor-affinity-programatically/

        /// </summary>

        private void ProcessorAffinityInit()

        {

            ProcessorAffinityList = new List<long>();

            int processCount = Environment.ProcessorCount;

            int AffinityScope = 1;

            if (processCount > MultiProcessCount)

            {

                AffinityScope = processCount / MultiProcessCount;

            }

            for (int i = 0; i < processCount - AffinityScope; i += AffinityScope)

            {

                var bits = new int[processCount];

                for (int j = i; j < i + AffinityScope; j++)

                {

                    bits[j] = 1;

                }

                var affinity = System.Convert.ToInt64(string.Join("", bits), 2);

                ProcessorAffinityList.Add(affinity);

            }

        }

        public bool StartService()

        {

            try

            {

                this.GetApplicationConfig();

                logger.Info("Read Config");

                ProcessorAffinityInit();

            }

            catch (Exception e)

            {

                throw new Exception("Stop StartService Error. ", e);

            }

            try

            {

                // MarkusPDF.dll에서 pThread lib 사용을 위해 Insatll

                if (!File.Exists(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "libpthread.dll")))

                {

                    Markus.Library.Installer.Install();

                    logger.Info("Markus.Library.Installer Install");

                }

                else

                {

                    logger.Info("Markus.Library.Installer Exists.");

                }

            }

            catch (Exception e)

            {

                throw new Exception("Stop Installer Error. ", e);

            }

            try

            {

                // 기존에 실행 중이던 프로세스 종료

                Stopprocess();

                logger.Info("Stopprocess");

            }

            catch (Exception e)

            {

                throw new Exception("Stop Process Error. ", e);

            }

            try

            {

                // WCF 실행

                StartWcfService();

                if (gWcfServiceHost.BaseAddresses?.Count() > 0)

                {

                    gServiceHostAddress = gWcfServiceHost.BaseAddresses.First();

                }

                //  각 서비스에 컨버터 아이템을 보내기 위한 서비스 초기화

                if (IsStation)

                {

                    SetServiceList(this.StationServiceIDList);

                }

                logger.Info($"StartWcfService {gServiceHostAddress}");

            }

            catch (Exception e)

            {

                throw new Exception("start Wcf Service Error. ", e);

            }

            //try

            //{

            //    // Status가 4이하인 Convert Item을 다시 Convert 함. 

            //    setDataBaseWaitingList();

            //    logger.Info("setDataBaseWaitingList");

            //}

            //catch (Exception e)

            //{

            //    throw new Exception("Database Waiting List Error . ", e);

            //}

            logger.Info("Start ServiceStation");

            timer = new System.Timers.Timer(1000);// new TimeSpan(0,0,0,10).TotalMilliseconds);

            timer.Elapsed += Timer_Elapsed;

            timer.AutoReset = true;

            timer.Start();

            return true;

        }

        public void SetServiceList(List<string> serviceList)

        {

            StationServiceList = new List<SubStationServiceItem>();

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

            {

                foreach (var item in serviceList)

                {

                    try

                    {

                        var prop = database.GetServiceProperties(item);

                        if (prop != null)

                        {

                            BasicHttpBinding myBinding = new BasicHttpBinding();

                            EndpointAddress myEndpoint = new EndpointAddress(UriHelper.UriCreate(prop.SERVICE_ADDRESS));

                            var StationServiceClient = new WcfClient.StationServiceAsync.StationServiceClient(myBinding, myEndpoint);

                                //var items = StationServiceClient.AliveConvertList();

                                StationServiceList.Add(new SubStationServiceItem

                                {

                                    Properties = prop,

                                    Service = StationServiceClient

                                });

                        }

                    }

                    catch (Exception ex)

                    {

                        logger.Error($"Service Properties Error  ID : { item }",ex);

                    }

                }

            }

        }

        protected override void OnStop()

        {

            try

            {

                timer.Stop();

                StopWcfService();

                Stopprocess();

                logger.Info("ServiceStation Stop");

            }

            catch (Exception e)

            {

                logger.Error("OnStop Error . ", e);

            }

        }

        #region Sleep 방지

        //[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]

        //static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE esFlags);

        //[FlagsAttribute]

        //public enum EXECUTION_STATE : uint

        //{

        //    ES_AWAYMODE_REQUIRED = 0x00000040,

        //    ES_CONTINUOUS = 0x80000000,

        //    ES_DISPLAY_REQUIRED = 0x00000002,

        //    ES_SYSTEM_REQUIRED = 0x00000001

        //    // Legacy flag, should not be used.

        //    // ES_USER_PRESENT = 0x00000004

        //}

        //public static void PreventScreenAndSleep()

        //{

        //    SetThreadExecutionState(EXECUTION_STATE.ES_CONTINUOUS |

        //                            EXECUTION_STATE.ES_SYSTEM_REQUIRED |

        //                            EXECUTION_STATE.ES_AWAYMODE_REQUIRED |

        //                            EXECUTION_STATE.ES_DISPLAY_REQUIRED);

        //} 

        #endregion

    }

}