MARKUS

using log4net;

using Markus.EntityModel;

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.ServiceModel.Channels;

using System.ServiceModel.Dispatcher;

using System.ServiceProcess;

using System.Text;

using System.Threading;

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 SERVICE_PROPERTIES ServiceProperty;

        private string ServiceID;

        private List<SubStationServiceItem> StationServiceList;

        private List<string> StationServiceIDList;

        private Service.WcfClient.StationServiceTask.StationServiceClient StationClient;

        private bool IsStation;

        private Uri gServiceHostAddress;

        private string MarkusDBConnectionString;

        private string DownloadTempFolder;

        private string FontsFolder;

        private int MultiThreadMaxPages;

        private int MinFontSize;

        private int UseResolution;

        private bool CreateProcessWindow;

        private long ReleaseWorkMemory;

        private int SaveStatusInterval;

        private bool IsReleaseItems;

        private readonly System.Timers.Timer timer= null;

        private readonly object locker = new object();

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

        /// <summary>

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

        /// </summary>

        private List<Int64> ProcessorAffinityList;

        private string configFileName;

        public ServiceStation()

        {

            InitializeComponent();

            timer = new System.Timers.Timer(new TimeSpan(0, 0, 0,1).TotalMilliseconds);

            timer.Elapsed += timerWorkMethod;

        }

        /// <summary>

        /// Config 파일 

        /// </summary>

        public void GetApplicationConfig()

        {

            try

            {

                ConfigParser config = null;

                try

                {

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

                    config = ConfigHelper.AppConfig(this.configFileName);

                }

                catch (Exception ex)

                {

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

                }

                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.StationServiceTask.StationServiceClient(myBinding, myEndpoint);

                        }

                    }

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

                    FontsFolder = config.GetValue(CONFIG_DEFINE.SERVICE, CONFIG_DEFINE.FONTS_FOLDER, "C:\\MarkusFonts"); 

                    // pThraed를 이용한 컨버팅 설정.

                    //최대 페이지가 MultiThreadMaxPages설정까지 pThread를 적용하여 컨버팅함.

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

                    // 서비스 상태 Log 저장간격

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

                    //PDF에 폰트가 최소 폰트 사이즈보다 작은 사이증의 폰트가 있으면 해상도를 높여서 컨버팅함.

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

                    // 사용자 설정의 해상도

                    // MinFontSize를 -1로 하고 UseResolution를 설정하면 해당 해상도로 컨버팅됨

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

                    }

                    // 각  ConvertService의 원격 관리를 위한 서비스 설정 로드

                    using (Markus.Service.DataBase.ConvertDatabase db = new Markus.Service.DataBase.ConvertDatabase(MarkusDBConnectionString))

                    {

                        ServiceProperty = db.GetServiceProperties(ServiceID);

                    }

                }

            }

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

            }

        }

        /// <summary>

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

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

        /// </summary>

        private void ReleaseItems()

        {

            try

            {

                IsReleaseItems = true;

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

                CleanUpAliveQueueItems();

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

                if (IsStation)

                {

                    //if (IsDataBaseWaitingList(1))

                    //{

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

                    var task = ReflashSubServiceAsync();

                    if(task.Wait(40000))

                    {

                        if (task.Result)

                        {

                            if (StationServiceList.All(x => x.IsOnline))

                            {

                                CleanUpDataBaseItems();

                                setDataBaseWaitingList();

                            }

                            else

                            {

                                logger.Error("Service Any Offline");

                            }

                        }

                        else

                        {

                            logger.Error("ReleaseItems - ReflashSubServiceAsync result false");

                        }

                    }

                    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 = processCount;

            if (processCount > ServiceProperty.PROCESS_COUNT)

            {

                AffinityScope = processCount / ServiceProperty.PROCESS_COUNT;

            }

            long affinityMask = 0;

            while (ProcessorAffinityList.Count() < ServiceProperty.PROCESS_COUNT)

            {

                if(affinityMask <= 1)

                {

                    affinityMask = 1 << (processCount - 1);

                }

                else

                {

                    affinityMask = affinityMask >>1;

                }

                ProcessorAffinityList.Add(affinityMask);

            }

//            for (int i = 0; i < 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);

//#if DEBUG

//                List<int> test = bits.ToList();

//                test.Reverse();

//               System.Diagnostics.Debug.WriteLine($"index{string.Format("0#",i)} - {string.Join("", test)}");

//#endif

//                ProcessorAffinityList.Add(affinity);

//            }

        }

        public void StartService()

        {

            /// 서비스 설정 로드

            try

            {

                this.GetApplicationConfig();

                logger.Info("Read Config");

                if (ServiceProperty != null)

                {

                    ProcessorAffinityInit();

                }

                else

                {

                    throw new Exception("StartService Error. ServiceProperty is Null");

                }

            }

            catch (Exception e)

            {

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

            }

            /// pThread.dll을 리소스에서 Service 실행 디렉토리로 복사.

            //try

            //{

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

            //    var libPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "\\convert\\libpthread.dll");

            //    if (!File.Exists(libPath))

            //    {

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

            }

            /// wcf 서비스 실행

            try

            {

                // WCF 실행

                StartWcfService();

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

                {

                    gServiceHostAddress = gWcfServiceHost.BaseAddresses.First();

                }

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

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

        }

        private void timerWorkMethod(object sender, ElapsedEventArgs e)

        {

            if (timer.Enabled)

            {

                var _timer = (System.Timers.Timer)sender;

                _timer.Stop();

                if (!IsStop)

                {

                    StartConvert();

                    _timer.Start();

                }

                else

                {

                    StopService();

                }

            }

            else

            {

                logger.Error("timer disable");

            }

        }

        private bool IsStop = false;

        DateTime logTime;

        DateTime ReleaseTime;

        private bool StartConvert()

        {

            //stateTimer.Change(new TimeSpan(0, 0, 0), new TimeSpan(0, 0, 0, 0, -1));

            try

            {

                if ((DateTime.Now - ReleaseTime) >= new TimeSpan(0, 0,1))

                {

                    if (!IsReleaseItems)

                    {

                        if (System.Environment.UserInteractive)

                        {

                            Console.WriteLine("Release Items");

                        }

                        logger.Info("Release Items");

                        ReleaseItems();

                    }

                    else

                    {

                        if (System.Environment.UserInteractive)

                        {

                            Console.WriteLine("pass Release Items");

                        }

                    }

                    ReleaseTime = DateTime.Now;

                }

                if ((DateTime.Now - logTime) >= new TimeSpan(0, 5,0))

                {

                    logTime = DateTime.Now;

                    logger.Info("StationService Alive Check");

                }

            }

            catch (Exception ex)

            {

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

            }

            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 httpbinding = new BasicHttpBinding();

                            httpbinding.CloseTimeout = new TimeSpan(0, 10, 0);

                            httpbinding.ReceiveTimeout = new TimeSpan(0, 10, 0);

                            httpbinding.SendTimeout = new TimeSpan(0, 10, 0);

                            httpbinding.OpenTimeout = new TimeSpan(0, 10, 0);

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

                            var StationServiceClient = new WcfClient.StationServiceTask.StationServiceClient(httpbinding, 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

            {

                IsStop = true;

            }

            catch (Exception e)

            {

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

            }

        }

        public void StopService()

        {

            StopWcfService();

            Stopprocess();

            logger.Info("ServiceStation Stop");

        }

        #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

    }

}