using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Configuration;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using Timer = System.Timers.Timer;
using System.Collections;
using Edge.Core.Processor;
using Edge.Core.IndustryStandardInterface.Pump;
using Wayne.FDCPOSLibrary;
using System.Xml;
using Edge.Core.Database.Models;
using System.Threading.Tasks;
using Edge.Core.Processor.Communicator;
using Edge.Core.Processor.Dispatcher.Attributes;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Stateless;
using Edge.Core.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace Gilbarco_Pump
{

    #region Ctor parameters

    public class PumpGroupConfig
    {
        /// <summary>
        /// 数据发送端的地址编号
        ///     一般是指FCC? 则应该是一个全局共享值,放0xE0
        /// </summary>
        public byte FccCommAddress { get; set; } = 0xE0;

        /// <summary>
        /// 数据接收端的地址编号
        ///     指油机端的配置值，应该是每个通讯链路都不一样，一个链路上可能有1个或者多个加油点
        /// </summary>
        public byte DispenserCommBoardAddress { get; set; }

        public List<PumpConfig> PumpConfigs { get; set; }
    }

    public class PumpConfig
    {
        /// <summary>
        /// used by Fcc inside, the classic pump id concept.
        /// </summary>
        public byte PumpId { get; set; }

        /// <summary>
        /// 枪号为以整个加油站为基础的油枪顺序编号
        ///     就是全站枪号？
        /// </summary>
        public byte DispenserSideNozzleId { get; set; }
    }

    #endregion
    /// <summary>
    /// 协议支持5787bps，8 位数据位，1 位起始位，1 位停止位，Even校验位
    /// </summary>
    [MetaPartsRequired(typeof(HalfDuplexActivePollingDeviceProcessor<,>))]
    [MetaPartsRequired(typeof(ComPortCommunicator<>))]
    [MetaPartsRequired(typeof(TcpClientCommunicator<>))]
    [MetaPartsDescriptor(
       "lang-zh-cn:吉尔巴克加油机lang-en-us:Gilbarco dispenser",
       "用于驱动 吉尔巴克 加油机",
       new[] { "lang-zh-cn:加油机lang-en-us:Pump" })]
    public class PumpGroupHandler : IEnumerable<IFdcPumpController>, IDeviceHandler<byte[], MessageTemplateBase>
    {
        private IServiceProvider services;
        private ILogger logger = NullLogger.Instance;
        public PumpGroupConfig pumpGroupConfig;

        protected IEnumerable<NozzleExtraInfo> nozzleExtraInfos;
        protected IContext<byte[], MessageTemplateBase> context;
        protected IEnumerable<StatePumpHandler> pumpHandlers;

        private object rotateFrameNo_Guard = new object();
        /// <summary>
        /// </summary>
        private byte rotateFrameNo = 0;

        /// <summary>
        /// get a valid FrameNo which from >=1 and <= 0x3F.
        /// </summary>
        /// <returns></returns>
        public byte GenerateNewFrameNo()
        {
            lock (this.rotateFrameNo_Guard)
            {
                //return 0;
                if (this.rotateFrameNo > 0x3E)
                    this.rotateFrameNo = 0;
                return (byte)(++this.rotateFrameNo);
            }
        }


        [ParamsJsonSchemas("PumpGroupHandlerCtorParamsJsonSchemas")]
        public PumpGroupHandler(PumpGroupConfig pumpGroupConfig, IServiceProvider services)
        {
            this.pumpGroupConfig = pumpGroupConfig;
            this.services = services;
            var loggerFactory = services.GetRequiredService<ILoggerFactory>();
            this.logger = loggerFactory.CreateLogger("PumpHandler");
            this.pumpHandlers =
                pumpGroupConfig.PumpConfigs.Select(pc =>
                    new StatePumpHandler(this, pc.PumpId, pc.DispenserSideNozzleId, services)).ToList();
        }

        public void OnFdcServerInit(Dictionary<string, object> parameters)
        {
            if (parameters != null && parameters.TryGetValue("NozzleProductMapping", out object param))
            {
                this.nozzleExtraInfos = param as IEnumerable<NozzleExtraInfo>;
            }
        }

        public void Init(IContext<byte[], MessageTemplateBase> context)
        {
            this.context = context;
            var timeWindowWithActivePollingOutgoing =
                this.context.Outgoing as TimeWindowWithActivePollingOutgoing<byte[], MessageTemplateBase>;
            //this.pollingInterval = timeWindowWithActivePollingOutgoing.PollingInterval;
            timeWindowWithActivePollingOutgoing.PollingMsgProducer =
                () =>
                {
                    return null;
                };
            this.pumpHandlers.ToList().ForEach(p => p.Init(this.context));

            this.context.Incoming.OnLongTimeNoSeeMessage += (_, __) =>
            {
                this.pumpHandlers.ToList().ForEach(p => p.TriggerPumpOffline());
            };
            this.context.Incoming.LongTimeNoSeeMessageTimeout = 6000;
        }

        public async Task Process(IContext<byte[], MessageTemplateBase> context)
        {
            this.context = context;
            foreach (var ph in this.pumpHandlers)
                await ph.Process(context);
        }

        public IEnumerator<IFdcPumpController> GetEnumerator()
        {
            return this.pumpHandlers.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.pumpHandlers.GetEnumerator();
        }
    }
}