FCC/Devices/Pumps/Censtar_31064V105OrV106_Pump/PumpGroupHandler.cs

using Censtar_31064V105OrV106_Pump.MessageEntity;
using Censtar_31064V105OrV106_Pump.MessageEntity.Outgoing;
using Edge.Core.IndustryStandardInterface.Pump;
using Edge.Core.Parser.BinaryParser.MessageEntity;
using Edge.Core.Processor;
using Edge.Core.UniversalApi;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;

namespace Censtar_31064V105OrV106_Pump
{
    public class PumpGroupHandler : IEnumerable<IFdcPumpController>, IDeviceHandler<byte[], MessageTemplateBase>
    {
        public enum DispenserModelEnum
        {
            Model_31064V105 = 0,
            Model_31064V106 = 1
        }

        /// <summary>
        /// 加油后是否加锁标志
        /// </summary>
        //public enum DispenserPostFuelingLockModeEnum
        //{
        //    加油后加锁_不可解锁,
        //    加油后加锁_可解锁,
        //    加油后不加锁,
        //    室外解锁密码_3位长度密码,
        //}

        /// <summary>
        /// 控制加油枪授权出油的方式
        /// </summary>
        public enum DispenserAuthorizeModeEnum
        {
            /// <summary>
            /// 感觉像是提枪就出油???
            /// </summary>
            开放 = 0,

            /// <summary>
            /// 加油机需要获得  “开机信号” 才可以出油。
            /// </summary>
            监控 = 1,
        }

        /// <summary>
        /// seems one dispenser is a basic comm unit??
        /// </summary>
        public class DispenserParameter
        {
            public DispenserModelEnum? DispenserModel { get; set; } = DispenserModelEnum.Model_31064V105;
            public SetPostFuelingLockTypeRequest.LockTypeEnum? DispenserPostFuelingLockMode { get; set; } = SetPostFuelingLockTypeRequest.LockTypeEnum.加油后不加锁;
            public DispenserAuthorizeModeEnum? DispenserAuthorizeMode { get; set; } = DispenserAuthorizeModeEnum.监控;

            public class PumpParameter
            {
                /// <summary>
                /// seems the dispendser side has no this concept??
                /// </summary>
                public int PumpId { get; set; }

                public int? AmountDecimalDigits { get; set; } = 2;

                public int? VolumeDecimalDigits { get; set; } = 2;

                public int? PriceDecimalDigits { get; set; } = 2;

                public int? VolumeTotalizerDecimalDigits { get; set; } = 2;

                public IEnumerable<NozzleParameter> NozzleParameters { get; set; }
            }

            public class NozzleParameter
            {
                public byte NozzleNumber { get; set; }
            }


            public IEnumerable<PumpParameter> PumpParameters { get; set; }
        }

        private IContext<byte[], MessageTemplateBase> context;
        private List<StatePumpHandler> pumpHandlers;
        private IServiceProvider services;
        static ILogger logger = NullLogger.Instance;
        public PumpGroupHandler(DispenserParameter dispenserParameter, IServiceProvider services)
        {
            this.CreatePumpHanlders(dispenserParameter);
        }

        public PumpGroupHandler(string rawUglyEncodedCommaJsonStr_Of_DispenserParameter, IServiceProvider services)
        {
            var loggerFactory = services.GetRequiredService<ILoggerFactory>();
            logger = loggerFactory.CreateLogger("PumpHandler");
            this.services = services;

            var jsonSerializerOptions = new JsonSerializerOptions()
            {
                WriteIndented = true,
            };
            jsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());

            var decoded = rawUglyEncodedCommaJsonStr_Of_DispenserParameter.Replace("____UglyEncodedComma____", ",");
            var dispenserParameter = JsonSerializer.Deserialize<DispenserParameter>(decoded, jsonSerializerOptions);
            this.CreatePumpHanlders(dispenserParameter);
        }

        private void CreatePumpHanlders(DispenserParameter dispenserParameter)
        {
            this.pumpHandlers = new List<StatePumpHandler>();
            this.pumpHandlers.AddRange(
                dispenserParameter.PumpParameters.Select(pp =>
                    new StatePumpHandler(pp, services)
                    {
                        DispenserModel = dispenserParameter.DispenserModel.Value,
                        DispenserAuthorizeMode = dispenserParameter.DispenserAuthorizeMode.Value,
                        DispenserPostFuelingLockMode = dispenserParameter.DispenserPostFuelingLockMode.Value,
                        AmountDecimalDigits = pp.AmountDecimalDigits.Value,
                        PriceDecimalDigits = pp.PriceDecimalDigits.Value,
                        VolumeDecimalDigits = pp.VolumeDecimalDigits.Value,
                        VolumeTotalizerDecimalDigits = pp.VolumeTotalizerDecimalDigits.Value
                    }));
        }

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

        public void Init(IContext<byte[], MessageTemplateBase> context)
        {
            this.context = context;
            this.pumpHandlers.ForEach(p => p.Init(this.context));
            var timeWindowWithActivePollingOutgoing =
                this.context.Outgoing as TimeWindowWithActivePollingOutgoing<byte[], MessageTemplateBase>;
            int previousPolledHandlerIndex = 0;
            var nozzlePhysicalIds = this.pumpHandlers.SelectMany(ph => ph.Nozzles.Select(n => n.PhysicalId)).ToList();
            timeWindowWithActivePollingOutgoing.PollingMsgProducer = () =>
            {
                if (this.pumpHandlers.Count <= previousPolledHandlerIndex)
                    previousPolledHandlerIndex = 0;
                var nextNozzlePhysicalId = nozzlePhysicalIds[previousPolledHandlerIndex++];
                return new ReadRealTimeData() { NozzleNumber = nextNozzlePhysicalId };
            };
        }

        public Task Process(IContext<byte[], MessageTemplateBase> context)
        {
            this.context = context;
            var msg = ((MessageBase)(context.Incoming.Message));
            var ph = this.pumpHandlers.FirstOrDefault(ph => ph.Nozzles.Select(n => n.PhysicalId).Contains(msg.NozzleNumber));
            if (ph == null)
            {
                logger.LogInformation("PumpGroupHandler does not contain pumpHandler with NozzlePhyscialId: 0x"
                    + msg.NozzleNumber.ToString("X2"));
                return Task.CompletedTask;
            }

            return ph.Process(context);
        }

        [UniversalApi]
        public Task<bool> ChangeFuelPriceAsync(int pumpId, int newPriceWithoutDecimalPoint, byte logicalNozzleId)
        {
            return this.pumpHandlers.FirstOrDefault(ph => ph.PumpId == pumpId)?.ChangeFuelPriceAsync(newPriceWithoutDecimalPoint, logicalNozzleId);
        }

        [UniversalApi]
        public Task<System.Tuple<int, int>> QueryTotalizerAsync(int pumpId, byte logicalNozzleId)
        {
            return this.pumpHandlers.FirstOrDefault(ph => ph.PumpId == pumpId)?.QueryTotalizerAsync(logicalNozzleId);
        }

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