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;

        private int MultiProcessCount = 1;

        private Uri gServiceHostAddress;

        private string MarkusDBConnectionString;

        private string DownloadTempFolder;

        private int MultiThreadMaxPages;

        private int MinFontSize;

        private bool CreateProcessWindow;

        private int SaveStatusInterval;

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

        /// <summary>

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

        /// </summary>

        private List<Int64> ProcessorAffinityList;

        private string configFileName;

        public ServiceStation()

        {

            InitializeComponent();

        }

        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)

                {

                    var processCount = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.CONVERT_SERVICE_PROCESS);

                    if (!string.IsNullOrWhiteSpace(processCount))

                    {

                        int outValue = 1;

                        if (int.TryParse(processCount, out outValue))

                        {

                            MultiProcessCount = outValue;

                        }

                    }

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

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

                    // CONVERT DATABASE 연결 문자열

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

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

            var process = Process.GetProcessesByName("Markus.Service.ConvertProcess");

            for (int i = 0; i < process.Count(); i++)

            {

                System.Diagnostics.Debug.WriteLine($"Command [{i}]: " , string.Join(" ", process[i].Arguments().CommandLine));

            }

            for (int i = 0; i < ServiceStation.AliveConvertQueue.Count; i++)

            {

                System.Diagnostics.Debug.WriteLine($"AliveConvertItems  [{i}]: ", ServiceStation.AliveConvertQueue[i].ConvertID);

            }

            System.Threading.Thread.Sleep(1000);

            timer.Start();

        }

        System.Timers.Timer timer;

        private void ProcessorAffinityInit_temp()

        {

            ProcessorAffinityList = new List<long>();

            int processCount = Environment.ProcessorCount;

            bool[] bits = new bool[processCount];

            for (int i = 0; i < bits.Count(); i+=3)

            {

                bits = new bool[processCount];

                bits[i] = true;

                bits[i+1] = true;

                bits[i + 2] = true;

                bits = bits.ToArray();

                var affinity = System.Convert.ToInt64(string.Join("", bits.Select(bit => (bit ? 1.ToString() : 0.ToString()))), 2);

                ProcessorAffinityList.Add(affinity);

            }

        }

        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

            {

                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

            {

                StartWcfService();

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

                {

                    gServiceHostAddress = gWcfServiceHost.BaseAddresses.First();

                }

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

            }

            catch (Exception e)

            {

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

            }

            try

            {

                setDataBaseWaitingList();

                logger.Info("setDataBaseWaitingList");

            }

            catch (Exception e)

            {

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

            }

            logger.Info("Start ServiceStation");

            //timer = new System.Timers.Timer(10000);

            //timer.Elapsed += Timer_Elapsed;

            //timer.AutoReset = true;

            //timer.Start();

            return true;

        }

        protected override void OnStop()

        {

            try

            {

                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

    }

}