//using Edge.Core.Processor;
//using System;
//using Microsoft.EntityFrameworkCore;
//using Microsoft.Extensions.DependencyInjection;
//using Microsoft.Extensions.Logging;
//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text.Json;
//using Edge.Core.UniversalApi;
//using Edge.Core.Processor.Dispatcher.Attributes;
//using System.Threading.Tasks;
//using System.Net.Sockets;
//using Microsoft.Extensions.Logging.Abstractions;
//using System.Net;
//using System.Threading;
//using Edge.Core.Parser.BinaryParser.Util;

//namespace DispenserPartsInfoRetriever
//{
//    /// <summary>
//    /// 市场方面希望将我们广州团队当初在“广东中石化加油机信息在线项目”中所开发的加油机上信息参数
//    /// </summary>
//    [UniversalApi(Name = OnAppStateChangeEventName, EventDataType = typeof(OnAppStateChangeEventArg), Description = "When the App overall State Changed, like app starts or stops, the event will be fired")]
//    [UniversalApi(Name = OnDispenserConnStateChangeEventName, EventDataType = typeof(OnDispenserConnStateChangeEventArg), Description = "When communication state changed for certain dispensere, like the connection between a dispenser and fcc is established or broken, the event will be fired")]
//    [MetaPartsDescriptor(
//       "油机配件信息获取器TCP版",
//       "用于获取油机配件的信息,日志标记为DynamicPrivate_DispenserPartsInfoRetriever,它通过半公开协议与油机通讯,采集油机端的较底层设备配件信息,并开放API供业务端应用."
//       , new[] { "Pump" })]
//    public class App_TcpServer : BaseServer
//    {
//        private class TcpClientInfo
//        {
//            public Action<byte[]> OnMessageCut { get; set; }
//            private List<byte> msgBuffer = new List<byte>();

//            /// <summary>
//            /// ip:port, like: 192.168.1.10:4567
//            /// </summary>
//            public string TcpEndPointIdentity { get; }
//            public TcpClient TcpClient { get; }
//            public DispenserInfoConfigV1 BoundDispenserInfoConfig { get; set; }
//            public TcpClientInfo(TcpClient tcpClient)
//            {
//                this.TcpClient = tcpClient;
//                this.TcpEndPointIdentity = tcpClient.Client.RemoteEndPoint.ToString();
//            }

//            public void FeedMessage(byte[] rawBytes)
//            {
//                if (!this.msgBuffer.Any())
//                {
//                    for (int i = 0; i < rawBytes.Length; i++)
//                    {
//                        if (rawBytes[i] == 0xFA)
//                        {
//                            this.msgBuffer.AddRange(rawBytes.Skip(i));
//                            break;
//                        }
//                    }
//                }
//                else
//                {
//                    this.msgBuffer.AddRange(rawBytes);
//                }

//                while (this.msgBuffer.Count >= 6)
//                {
//                    if (this.msgBuffer[0] != 0xFA) { this.msgBuffer.RemoveAt(0); continue; }
//                    var nxtMsgLen = 6 + this.msgBuffer[5];
//                    var nxtMsg = this.msgBuffer.Take(nxtMsgLen).ToArray();
//                    this.OnMessageCut?.Invoke(nxtMsg);
//                    this.msgBuffer.RemoveRange(0, nxtMsgLen);
//                }
//            }

//            public DateTime LastHeartbeatMessageReceivedTime { get; set; }
//        }

//        public static int tcpReceiveBufferSize = 1500;
//        private CancellationTokenSource tcpServerCts;

//        /// <summary>
//        /// the List is the message buffer, only a complete message is constructed, processing then start.
//        /// </summary>
//        private List<TcpClientInfo> tcpClientInfos = new List<TcpClientInfo>();
//        private System.Timers.Timer heartbeatTimer = new System.Timers.Timer();
//        private AppConfigV1 appConfig;
//        private IServiceProvider services;
//        private TcpListener tcpServer;
//        private ILogger logger = NullLogger.Instance;

//        public string MetaConfigName { get; set; }

//        [ParamsJsonSchemas("appCtorParamsJsonSchema")]
//        public App_TcpServer(AppConfigV1 appConfig, IServiceProvider services) : base(appConfig, services)
//        {
//            this.appConfig = appConfig;
//            this.services = services;

//            var loggerFactory = services.GetRequiredService<ILoggerFactory>();
//            this.logger = loggerFactory.CreateLogger("DynamicPrivate_DispenserPartsInfoRetriever");
//        }

//        public void Init(IEnumerable<IProcessor> processors)
//        {
//        }

//        public override async Task<bool> Start()
//        {
//            this.tcpServerCts = new CancellationTokenSource();
//            this.tcpServer = new TcpListener(IPAddress.Any, this.appConfig.ServerListenPort);
//            this.logger.LogInformation($"Starting TcpServer for listening for All IP on port: {this.appConfig.ServerListenPort}");
//            this.tcpServer.Start();
//            this.logger.LogInformation($"   TcpServer started");
//            var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
//            await universalApiHub.FireEvent(this, OnAppStateChangeEventName, new OnAppStateChangeEventArg() { State = "Started", Reason = "app is started" });
//            _ = Task.Run(async () =>
//            {
//                while (true)
//                {
//                    TcpClient newTcpClient = null;
//                    try
//                    {
//                        newTcpClient = await Task.Run(() => this.tcpServer.AcceptTcpClientAsync(), this.tcpServerCts.Token);
//                    }
//                    catch (TaskCanceledException tce)
//                    {
//                        this.logger.LogInformation("Fcc as the Tcp server is canceled due to CancellationTokenSource was set.");

//                        try
//                        {
//                            this.tcpServer?.Stop();
//                        }
//                        catch { return; }
//                        finally { }
//                    }

//                    var newTcpClientInfo = new TcpClientInfo(newTcpClient) { LastHeartbeatMessageReceivedTime = DateTime.Now };
//                    newTcpClientInfo.BoundDispenserInfoConfig = this.appConfig.DispenserInfoConfigs.FirstOrDefault(c =>
//                        newTcpClientInfo.TcpEndPointIdentity.StartsWith(c.IpAddress))
//                        ?? new DispenserInfoConfigV1()
//                        {
//                            Name = $"未命名油机({newTcpClientInfo.TcpEndPointIdentity})",
//                            IpAddress = newTcpClientInfo.TcpEndPointIdentity,
//                            Description = "此油机未在本地WebConsole中定义和配置名称"
//                        };

//                    this.logger.LogInformation($"New tcp client: { newTcpClientInfo.BoundDispenserInfoConfig.Name } is connected.");
//                    var existedTcpClientInfo = this.tcpClientInfos.FirstOrDefault(k => k.TcpEndPointIdentity == newTcpClient.Client.RemoteEndPoint.ToString());
//                    if (existedTcpClientInfo != null)
//                    {
//                        this.logger.LogInformation($"The incoming new tcp client: {newTcpClient.Client.RemoteEndPoint.ToString()} was already in inner connected list, why did it connect again? will remove the old existing one and re-add...");
//                        this.tcpClientInfos.Remove(existedTcpClientInfo);
//                    }

//                    newTcpClientInfo.OnMessageCut = (msg) =>
//                    {
//                        switch (msg[6])
//                        {
//                            case 0x80:
//                                if (logger.IsEnabled(LogLevel.Trace))
//                                    this.logger.LogTrace($"{ newTcpClientInfo.BoundDispenserInfoConfig.Name } incoming msg parsed as HeartbeatMessage");
//                                newTcpClientInfo.LastHeartbeatMessageReceivedTime = DateTime.Now;
//                                break;
//                            case 0x90:
//                                if (logger.IsEnabled(LogLevel.Trace))
//                                    this.logger.LogTrace($"{ newTcpClientInfo.BoundDispenserInfoConfig.Name } incoming msg parsed as DataMessage");
//                                newTcpClientInfo.LastHeartbeatMessageReceivedTime = DateTime.Now;
//                                var msgBody = msg.Skip(7).ToArray();
//                                try
//                                {
//                                    Utf8JsonReader reader = new Utf8JsonReader(msgBody);
//                                    JsonDocument jsonDocument = null;
//                                    if (!JsonDocument.TryParseValue(ref reader, out jsonDocument))
//                                    {
//                                        this.logger.LogInformation($"The tcp client: {newTcpClient.Client.RemoteEndPoint.ToString()} has invalid json DataMessage: 0x{msgBody.ToHexLogString()}");
//                                        return;
//                                    }

//                                    var rootEle = jsonDocument.RootElement;

//                                    //加油机基本信息
//                                    var dispenserBasicInfo_property = rootEle.GetProperty("dispenserBasicInfo");

//                                    //关键部件信息
//                                    var keycomponentInfo_property = rootEle.GetProperty("keycomponentInfo");

//                                    #region 加油机部件寿命信息

//                                    var dispenserLifecycleInfo_property = rootEle.GetProperty("dispenserLifecycleInfo");

//                                    //PSAM有效期
//                                    var PSAMvalidityDate_array = dispenserLifecycleInfo_property.GetProperty("PSAMvalidityDate").EnumerateArray();
//                                    foreach (var el in PSAMvalidityDate_array)
//                                    {
//                                        var nozzleNO = el.GetProperty("nozzleNO").GetString();
//                                        var validityDate = el.GetProperty("validityDate").GetDateTime();
//                                    }

//                                    //读卡器开关次数
//                                    var ReaderLifecycleInfo_array = dispenserLifecycleInfo_property.GetProperty("ReaderLifecycleInfo").EnumerateArray();
//                                    foreach (var el in ReaderLifecycleInfo_array)
//                                    {
//                                        var nozzleNO = el.GetProperty("nozzleNO").GetString();
//                                        var valveCycle = el.GetProperty("valveCycle").GetString();
//                                    }

//                                    //流量计升数
//                                    var meterLifecycleInfo_array = dispenserLifecycleInfo_property.GetProperty("meterLifecycleInfo").EnumerateArray();
//                                    foreach (var el in meterLifecycleInfo_array)
//                                    {
//                                        var nozzleNO = el.GetProperty("nozzleNO").GetString();
//                                        var meterSN = el.GetProperty("meterSN").GetString();
//                                        var meterVolume = el.GetProperty("meterVolume").GetString();
//                                    }

//                                    //电磁阀开关次数
//                                    var valveLifecycleInfo_array = dispenserLifecycleInfo_property.GetProperty("valveLifecycleInfo").EnumerateArray();
//                                    foreach (var el in valveLifecycleInfo_array)
//                                    {
//                                        var nozzleNO = el.GetProperty("nozzleNO").GetString();
//                                        var valveNum = el.GetProperty("valveNum").GetString();
//                                        var valveCycle = el.GetProperty("valveCycle").GetString();
//                                    }

//                                    #endregion


//                                    #region 设备定期检修记录

//                                    var periodicalmaintenanceInfo_property = rootEle.GetProperty("periodicalmaintenanceInfo");
//                                    var hydraulicsystemPMDate = periodicalmaintenanceInfo_property.GetProperty("hydraulicsystemPMDate").GetDateTime();
//                                    var controlsystemPMDate = periodicalmaintenanceInfo_property.GetProperty("controlsystemPMDate").GetDateTime();
//                                    var gasrecoverysystemPMDate = periodicalmaintenanceInfo_property.GetProperty("gasrecoverysystemPMDate").GetDateTime();

//                                    #endregion


//                                    #region 加油机报警信息

//                                    var dispenserAlarm_property = rootEle.GetProperty("dispenserAlarm");
//                                    var nozzleStatus_array = dispenserAlarm_property.GetProperty("nozzleStatus").EnumerateArray();
//                                    foreach (var el in nozzleStatus_array)
//                                    {
//                                        var nozzleNO = el.GetProperty("nozzleNO").GetString();
//                                        var zerotransactionAlarm = el.GetProperty("zerotransactionAlarm").GetString();
//                                        var powerAlarm = el.GetProperty("powerAlarm").GetString();
//                                        var fuelingspeedAlarm = el.GetProperty("fuelingspeedAlarm").GetString();
//                                        var encoderAlarm = el.GetProperty("encoderAlarm").GetString();
//                                        var prestovershootAlarm = el.GetProperty("prestovershootAlarm").GetString();
//                                        var lockAlarm = el.GetProperty("lockAlarm").GetString();
//                                        var valveAlarm = el.GetProperty("valveAlarm").GetString();
//                                        var leakageAlarm = el.GetProperty("leakageAlarm").GetString();
//                                        var nozzleoffbootAlarm = el.GetProperty("nozzleoffbootAlarm").GetString();
//                                        var vaporrecoveryRatioAlarm = el.GetProperty("vaporrecoveryRatioAlarm").GetString();
//                                    }

//                                    var taxchipAlarm_array = dispenserAlarm_property.GetProperty("taxchipAlarm").EnumerateArray();
//                                    foreach (var el in taxchipAlarm_array)
//                                    {
//                                        var nozzleNO = el.GetProperty("nozzleNO").GetString();
//                                        var taxchipAlarmCode = el.GetProperty("taxchipAlarmCode").GetString();
//                                    }

//                                    #endregion


//                                    //智能锁信息
//                                    var locker_property = rootEle.GetProperty("locker");
//                                }
//                                catch (Exception eeee)
//                                {
//                                    this.logger.LogInformation($"The tcp client: {newTcpClient.Client.RemoteEndPoint.ToString()} has fatal invalid json DataMessage: 0x{msgBody.ToHexLogString()}, exception: {eeee}");
//                                }

//                                break;
//                        }
//                    };
//                    var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
//                    await universalApiHub.FirePersistGenericAlarm(this,
//                        new GenericAlarm()
//                        {
//                            Title = $"{newTcpClientInfo.BoundDispenserInfoConfig?.Name ?? $"未命名油机联机"}",
//                            Severity = GenericAlarmSeverity.Information,
//                            Detail = $"{newTcpClientInfo.BoundDispenserInfoConfig?.Name ?? $"未命名油机(from {newTcpClientInfo.TcpEndPointIdentity}, 命名请通过配置 WebConsole)"}联机成功",
//                        }, ga => ga.Detail);
//                    await universalApiHub.FireEvent(this, OnDispenserConnStateChangeEventName,
//                        new OnDispenserConnStateChangeEventArg() { State = "Connected", DispenserName = $"{newTcpClient.Client.RemoteEndPoint.ToString()}", Reason = $"The dispenser with idenity: {newTcpClient.Client.RemoteEndPoint.ToString()} is tcp connected to fcc" });

//                    this.tcpClientInfos.Add(newTcpClientInfo);

//                    _ = Task.Run(async () =>
//                    {
//                        while (true)
//                        {
//                            byte[] buffer = new byte[tcpReceiveBufferSize];
//                            try
//                            {
//                                var readBytesCount = await newTcpClient.GetStream().ReadAsync(buffer, 0, tcpReceiveBufferSize);
//                                if (readBytesCount == 0)
//                                    throw new Exception("tcp client received 0 count data which indicates the connection is broken, trigger disconnection");
//                                var data = buffer.Take(readBytesCount).ToArray();
//                                try
//                                {
//                                    if (logger.IsEnabled(LogLevel.Trace))
//                                        this.logger.LogTrace($"TCP from {newTcpClientInfo.BoundDispenserInfoConfig.Name}) <---Incoming: 0x" + data.ToHexLogString());
//                                    newTcpClientInfo.FeedMessage(data);
//                                }
//                                catch (Exception exxx)
//                                {
//                                    this.logger.LogInformation($"Handle incoming msg on Tcp client: {newTcpClient.Client.RemoteEndPoint.ToString()} exceptioned: {exxx + Environment.NewLine}will ignore this msg and go on listening...");
//                                }
//                            }
//                            catch (Exception tcpExp)
//                            {
//                                this.logger.LogInformation($"Tcp client: {newTcpClientInfo.BoundDispenserInfoConfig.Name ?? ""} GetStream().ReadAsync exceptioned: {tcpExp + Environment.NewLine}treat as tcp connection broken");
//                                this.tcpClientInfos.Remove(newTcpClientInfo);
//                                var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
//                                await universalApiHub.FirePersistGenericAlarm(this,
//                                    new GenericAlarm()
//                                    {
//                                        Title = $"{newTcpClientInfo.BoundDispenserInfoConfig.Name }断联",
//                                        Severity = GenericAlarmSeverity.Error,
//                                        Detail = $"{newTcpClientInfo.BoundDispenserInfoConfig.Name}断联, exception: {tcpExp}",
//                                    }, ga => ga.Detail);
//                                await universalApiHub.FireEvent(this, OnDispenserConnStateChangeEventName,
//                                    new OnDispenserConnStateChangeEventArg()
//                                    {
//                                        State = "Disconnected",
//                                        DispenserName = $"{newTcpClientInfo.BoundDispenserInfoConfig.Name}",
//                                        Description = $"{newTcpClientInfo.BoundDispenserInfoConfig?.Description ?? ""}",
//                                        Reason = $"The dispenser with idenity: {newTcpClient.Client.RemoteEndPoint.ToString()} is tcp disconnected to fcc with exception: {tcpExp}"
//                                    });
//                                break;
//                            }
//                        }
//                    });
//                }
//            });
//            this.heartbeatTimer.Elapsed += async (s, a) =>
//            {
//                var connectedDispenserInfo = this.appConfig.DispenserInfoConfigs.Join(this.tcpClientInfos, diConfig => diConfig.IpAddress, tci => tci.TcpEndPointIdentity.Split(':').First(), (tci, diConfig) => tci);
//                var disconnectedDispenserInfo = this.appConfig.DispenserInfoConfigs.Except(connectedDispenserInfo);
//                foreach (var di in disconnectedDispenserInfo)
//                {
//                    var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
//                    await universalApiHub.CloseAndFirePersistGenericAlarm(this,
//                        new GenericAlarm()
//                        {
//                            Title = $"{di.Name ?? ""} 未主动联入",
//                            Severity = GenericAlarmSeverity.Error,
//                            Detail = $"{di.Name ?? ""} ({di.Description}) 未见此油机(本地配置其IP为: {di.IpAddress})主动通过 TCP 连入 FCC"
//                        }, ga => ga.Detail, "new one is on creating", ga => ga.Detail);
//                    await universalApiHub.FireEvent(this, OnDispenserConnStateChangeEventName,
//                        new OnDispenserConnStateChangeEventArg()
//                        {
//                            State = "Disconnected",
//                            DispenserName = $"{di.Name ?? $""}",
//                            Description = $"{di.Description ?? ""}",
//                            Reason = $"have not see the dispenser(local config its ip to: {di.IpAddress}) actively connected in for a while"
//                        });
//                }

//                if (!this.tcpClientInfos.Any()) return;
//                var longTimeNoSeeHbClientInfos =
//                    this.tcpClientInfos.Where(tci => DateTime.Now.Subtract(tci.LastHeartbeatMessageReceivedTime).TotalSeconds >= 15).ToArray();
//                foreach (var ci in longTimeNoSeeHbClientInfos)
//                {
//                    try
//                    {
//                        this.logger.LogInformation($"Client: {ci.BoundDispenserInfoConfig?.Name ?? $"未命名油机"} long time no see its heartbeat msg, will close and remove it...");
//                        ci.TcpClient.Close();
//                    }
//                    catch { }
//                    finally
//                    {
//                        this.tcpClientInfos.Remove(ci);
//                    }
//                }

//                //sample: 0xfa 00 00 00 00 08 80 20 21 05 21 10 16 14
//                var hbHexData = new byte[] { 0xFA, 0x00, 0x00, 0x00, 0x00, 0x08, 0x80 }.Concat(StringToBcdHex(DateTime.Now.ToString("yyyyMMddHHmmss"))).ToArray();
//                foreach (var ci in this.tcpClientInfos)
//                {
//                    try
//                    {
//                        if (logger.IsEnabled(LogLevel.Trace))
//                            this.logger.LogTrace($"TCP to { ci.BoundDispenserInfoConfig.Name  } --->Outgoing: 0x" + hbHexData.ToHexLogString());
//                        ci.TcpClient.Client.Send(hbHexData);
//                    }
//                    catch (Exception ee)
//                    {
//                        this.logger.LogInformation($"Exceptioned at send heartbeat message to tcp client: { ci.BoundDispenserInfoConfig.Name }, detail: {ee}");
//                    }
//                }
//            };
//            this.heartbeatTimer.Interval = this.appConfig.HeartbeatInterval * 1000;
//            this.heartbeatTimer.Start();
//            return true;
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        /// <param name="value">like input "01234", will return byte[2]: 0x00, byte[1]: 0x12, byte[0]: 0x34</param>
//        /// <returns></returns>
//        public byte[] StringToBcdHex(string value)
//        {
//            if (value.Length % 2 != 0) value = "0" + value;
//            List<byte> output = new List<byte>();
//            for (int i = value.Length - 1; i >= 0; i = i - 2)
//            {
//                output.Add((byte)(byte.Parse(value[i - 1].ToString()) * 16 + byte.Parse(value[i].ToString())));
//            }

//            output.Reverse();
//            return output.ToArray();
//        }

//        public async Task<bool> Stop()
//        {
//            var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
//            await universalApiHub.FireEvent(this, OnAppStateChangeEventName, new OnAppStateChangeEventArg() { State = "Stopped", Reason = "app is stopping" });
//            try { this.tcpServerCts?.Cancel(); } catch { }
//            try { this.tcpServer?.Stop(); } catch { }
//            try { this.heartbeatTimer?.Stop(); } catch { }
//            return true;
//        }
//    }
//}