FCC/Devices/Pumps/HengShan_Pump_TQC_IFSF/PetroChinaSilentPumpGroupHandler.cs

using Edge.Core.Processor;
using Edge.Core.IndustryStandardInterface.Pump;
using HengShan_Pump_TQC_IFSF.MessageEntity;
using HengShan_Pump_TQC_IFSF.MessageEntity.Incoming;
using HengShan_Pump_TQC_IFSF.MessageEntity.Outgoing;
using Edge.Core.Parser.BinaryParser.Util;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using Wayne.FDCPOSLibrary;
using Timer = System.Timers.Timer;
using Edge.Core.Processor.Dispatcher.Attributes;
using Edge.Core.Processor.Communicator;
using Edge.Core.UniversalApi;

namespace HengShan_Pump_TQC_IFSF
{
    public class PetroChinaSilentPumpGroupConfiguration : PumpGroupConfiguration
    {
        /// <summary>
        /// this feature is used in 中油站, this site support 2 kinds of payment way for fueling: 
        ///     1. insert driver card, pump get authorized, when done fuelling, charged from card.
        ///     2. lift nozzle directly to start fueling, when done fuelling, driver pay at indoor.
        ///     
        /// to determine which payment way is currectly used by only using IFSF is by checking Fdc pump state change sequence.
        ///     Calling->Fuelling means the pump didn't get authorized, the attandant just directly lift nozzle and fueling
        ///     Authorized->Fuelling means the driver inserted card firstly and then start fueling.
        /// </summary>
        public bool HiddenIcCardAuthorizedFuelTrxToFdcServerApp { get; set; }
    }

    /// <summary>
    /// silent means this pump group handler never actively send data to TQC, this is a solution for 
    /// a special TQC pump only passthrough sales data to FC, because it's controlled by other party FC.
    /// </summary>
    [UniversalApi(Name = OnPetroChinaIcCardAuthorizedFuelTrxDone_EventName, EventDataType = typeof(FdcTransactionDoneEventArg),
        Description = "When a pump trx was started by user inserted IC card on dispenser card reader first, this is called of type IC card authorized trx, this event is for popup these trx(the only other type of lifting nozzle and start fueling is not in this case)")]
    [MetaPartsRequired(typeof(GenericDeviceProcessor<,>))]
    [MetaPartsRequired(typeof(HengShan_TQC_IFsfMessageTcpIpCommunicator_Silent<>))]
    [MetaPartsDescriptor("中油 HS TQC 只读模式加油机",
        "用于中油站中驱动只读模式下的基于TCP连接的IFSF协议的恒山TQC加油机",
        new[] { "lang-zh-cn:加油机lang-en-us:Pump" })]
    public class PetroChinaSilentPumpGroupHandler : PumpGroupHandler
    {
        public const string OnPetroChinaIcCardAuthorizedFuelTrxDone_EventName = "OnPetroChinaIcCardAuthorizedFuelTrxDone";
        public event EventHandler<FdcTransactionDoneEventArg> OnPetroChinaIcCardAuthorizedFuelTrxDone;

        private bool hiddenIcCardAuthorizedFuelTrxToFdcServerApp;

        [ParamsJsonSchemas("PetroChinaSilentPumpGroupHandlerCtorParamsJsonSchemas")]
        public PetroChinaSilentPumpGroupHandler(PetroChinaSilentPumpGroupConfiguration pumpGroupConfiguration, IServiceProvider services)
            : base(pumpGroupConfiguration, services)
        {
            this.hiddenIcCardAuthorizedFuelTrxToFdcServerApp = pumpGroupConfiguration.HiddenIcCardAuthorizedFuelTrxToFdcServerApp;
        }

        public override void Init(IContext<byte[], IfsfMessageBase> context)
        {
            base.context = context;
            this.context.Communicator.OnConnected += (e, f) =>
            {
                // each time communicator get disconnect, will trigger a re-init.
                logger.Info("node " + this.tqcPumpGroupInitializer.ifsfRecipientNode + ", OnCommunicator Connected, will hard set all pumps to Idle state anyway");
                this.pumpHandlers.ForEach(p => p.HandleFpStatusChange(FuellingPointStatus.Idle, null));
            };
            this.context.Communicator.OnDisconnected += (e, f) =>
            {
                logger.Info("node " + this.tqcPumpGroupInitializer.ifsfRecipientNode + ", OnCommunicator Disconnected, will hard set all pumps to Closed state anyway");
                this.pumpHandlers.ForEach(p => p.HandleFpStatusChange(FuellingPointStatus.Closed, null));
            };
            base.pumpHandlers.ForEach(p => p.Init(this.context));
            //this.timelyCheckConnection = new Timer(5000);
            //this.timelyCheckConnection.Elapsed += (_, __) =>
            //{
            //    if (DateTime.Now.Subtract(this.lastTimeRecieveHearbeat).TotalSeconds >= 12)
            //    {
            //        //logger.Debug("Heartbeat timed out, will turn all pumps("
            //        //    + this.pumpHandlers.Select(p => p.QueryStatus().ToString()).Aggregate((acc, n) => acc + "," + n)
            //        //    + ") to Closed state");
            //        logger.Info("node " + this.tqcPumpGroupInitializer.ifsfRecipientNode + ", have not seen heartbeat for >=12 seconds, will local set all pumps to Closed state anyway");
            //        this.pumpHandlers.ForEach(p => p.HandleFpStatusChange(FuellingPointStatus.Closed, null));
            //    }
            //};
            //this.timelyCheckConnection.Start();
        }

        protected override void CreatePumpHandlers(IEnumerable<XmlNode> pumpElements)
        {
            foreach (XmlNode pumpElement in pumpElements)
            {
                byte pumpPhysicalIdValue;
                var rawPumpPhysicalId = pumpElement.Attributes["physicalId"].Value;
                if (rawPumpPhysicalId.StartsWith("0x") || rawPumpPhysicalId.StartsWith("0X"))
                    pumpPhysicalIdValue = byte.Parse(pumpElement.Attributes["physicalId"].Value.Substring(2), NumberStyles.HexNumber);
                else
                    pumpPhysicalIdValue = byte.Parse(pumpElement.Attributes["physicalId"].Value);
                if (pumpPhysicalIdValue < 0x21 || pumpPhysicalIdValue > 0x24)
                    throw new ArgumentException("ifsf fuel point id must be range from 0x21 to 0x24, while the configuration passed in " + rawPumpPhysicalId);

                PetroChinaSilentPumpHandler pumpHandler = new PetroChinaSilentPumpHandler(this, int.Parse(pumpElement.Attributes["pumpId"].Value),
                    pumpPhysicalIdValue,
                    base.recipientSubnet, base.recipientNode,
                    pumpElement.InnerXml, GetNewMessageToken);
                base.pumpHandlers.Add(pumpHandler);
            }
        }

        private Dictionary<byte, List<System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>>> fp_cached_states
            = new Dictionary<byte, List<System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>>>();

        public override Task Process(IContext<byte[], IfsfMessageBase> context)
        {
            base.context = context;
            if (context.Incoming.Message is FuellingPointDb_FpStatus_Event fp_status_evt)
            {
                List<System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>> cached_fp_states;
                if (fp_cached_states.TryGetValue(fp_status_evt.TargetFuelPointId, out cached_fp_states))
                    cached_fp_states.Add(new System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>(DateTime.Now, fp_status_evt));
                else
                {
                    cached_fp_states = new List<System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>>() {
                            new System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>(DateTime.Now, fp_status_evt) };
                    fp_cached_states.Add(fp_status_evt.TargetFuelPointId, cached_fp_states);
                }
            }

            //if (context.Incoming.Message is FuellingTrxDb_TransactionBufferStatus_Event trx_evt)
            if (context.Incoming.Message is FuellingTrxDb_TransactionBufferStatus_Answer trx_answer)
            {
                List<System.Tuple<DateTime, FuellingPointDb_FpStatus_Event>> cached_fp_states;
                if (fp_cached_states.TryGetValue(trx_answer.TargetFuelPointId, out cached_fp_states))
                {
                    var authorizedState_tp = cached_fp_states.OrderByDescending(t => t.Item1).FirstOrDefault(t => t.Item2.FuelPointState == FuellingPointStatus.AUTHORISED);
                    cached_fp_states.Clear();
                    if (authorizedState_tp != null && this.hiddenIcCardAuthorizedFuelTrxToFdcServerApp)
                    {
                        if (trx_answer.State.HasValue && trx_answer.State != FuellingTrxDb_TransactionBufferStatus_Event.TransactionState.PAYABLE)
                            return Task.CompletedTask;
                        logger.Debug($"node { this.tqcPumpGroupInitializer.ifsfRecipientNode}, FpId: 0x{trx_answer.TargetFuelPointId.ToHexLogString()} " +
                            $"reports a trx done Answer with state: {(trx_answer.State != null ? trx_answer.State.ToString() : "")}, amt: {trx_answer.Amount}, vol: {trx_answer.Volume}, price: {trx_answer.Price}, seqNo.: {trx_answer.TransactionSeqNumber}, " +
                            $"will be muted to FdcServerApp since a historical IfsfFp.AUTHORISED was detected " +
                            $"with timestamp: {authorizedState_tp.Item1.ToString("MM-dd HH:mm:ss fff")}");
                        //+
                        //$"(other cached states are: " +
                        //$"{cached_fp_states.Select(s => s.Item2.FuelPointState + "-" + s.Item1.ToString("MM-dd HH:mm:ss fff")).Aggregate((acc, n) => acc + "; " + n)})");

                        //context.Outgoing.Write(new AcknowledgeMessage(
                        //   trx_answer.OriginatorSubnet, trx_answer.OriginatorNode,
                        //   PumpGroupHandler.originatorSubnet, PumpGroupHandler.originatorNode,
                        //   trx_answer.MessageToken,
                        //   trx_answer.DatabaseId,
                        //   MessageAcknowledgeStatus.ACK_PositiveAcknowledgeDataReceived));

                        var targetPumpHandler = this.pumpHandlers.FirstOrDefault(ph => ph.PumpPhysicalId == trx_answer.TargetFuelPointId);
                        var operatingFdcLogicalNozzle = targetPumpHandler?.Nozzles?.FirstOrDefault(n => n.LogicalId == trx_answer.LogicalNozzleId);
                        this.OnPetroChinaIcCardAuthorizedFuelTrxDone?.Invoke(this,
                            new FdcTransactionDoneEventArg((new FdcTransaction()
                            {
                                Nozzle = operatingFdcLogicalNozzle,
                                Amount = trx_answer.Amount,
                                Volumn = trx_answer.Volume,
                                Price = int.Parse(trx_answer.Price),
                                SequenceNumberGeneratedOnPhysicalPump = trx_answer.TransactionSeqNumber,
                                VolumeTotalizer = Convert.ToInt32(trx_answer.VolumeTotalizerAfterTrx ?? 0 * Math.Pow(10, targetPumpHandler?.VolumeTotalizerDecimalDigits ?? 2)),
                                Finished = true,
                            })));
                        return Task.CompletedTask;
                    }
                }
                else
                {
                    logger.Info($"node { this.tqcPumpGroupInitializer.ifsfRecipientNode}, FpId: 0x{trx_answer.TargetFuelPointId.ToHexLogString()} " +
                            $"reports a trx done with state: {trx_answer.State}, amt: {trx_answer.Amount}, vol: {trx_answer.Volume}, seqNo.: {trx_answer.TransactionSeqNumber}, " +
                            $"no historical FpState were cached for this Fp yet, will send to FdcServerApp anyway(possible duplicate, but leave FdcServerApp to filter)");
                }
            }

            base.RouteMessageToHandlers(context);
            // if (context.Incoming.Message is FuellingTrxDb_TransactionBufferStatus_Event trx_evt__)
            //     context.Outgoing.Write(new AcknowledgeMessage(
            //        trx_evt__.OriginatorSubnet, trx_evt__.OriginatorNode,
            //        PumpGroupHandler.originatorSubnet, PumpGroupHandler.originatorNode,
            //        trx_evt__.MessageToken,
            //        trx_evt__.DatabaseId,
            //        MessageAcknowledgeStatus.ACK_PositiveAcknowledgeDataReceived
            //));

            return Task.CompletedTask;
        }
    }
}