using Edge.Core.Processor;using Edge.Core.IndustryStandardInterface.Pump;
using MessageRouter;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Edge.Core.Parser;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Wayne.Lib.Log;
using Edge.Core.Processor.Communicator;

namespace GlobalCommunicator
{
    public class GlobalFccCommunicator<T> : ICommunicator<object, T> where T : MessageBase
    {
        public string Identity { get; set; }
        #region Fields

        private ILogger fccLogger;
        private const char CRYPT_FORMAT = '3';                          // Fusion message crypt format
        private const char MESSAGE_VERSION = '2';                       // Fusion message version
        private const int FUSION_MESSAGE_ROUTER_PORT = 3011;            // Fusion message router server port;

        private IMessageParser<object, T> parser;
        private string fdcServerIpAddress = null;
        private string clientId = null;
        private FdcCommunicator<T> fdcComm;

        /// <summary>
        /// 0 for not started, 1 for started.
        /// </summary>
        private int isStarted = 0;
        private bool disposed = false;
        private readonly object syncObj = new object();

        #endregion

        public event EventHandler OnConnected;
        public event EventHandler OnDisconnected;
        public event EventHandler<CommunicatorEventArg<object, T>> OnRawDataWriting;
        public event EventHandler<CommunicatorEventArg<object, T>> OnDataReceived;
        public event EventHandler<CommunicatorErrorMessageReadEventArg> OnErrorMessageRead;

        public GlobalFccCommunicator(IMessageParser<object, T> parser, string fdcServerIpAddress, string clientId, IServiceProvider services)
        {
            if (services != null)
            {
                var loggerFactory = services.GetRequiredService<ILoggerFactory>();
                fccLogger = loggerFactory.CreateLogger("GlobalPumpFdc");
                MessageRouterCommunicator<T>.fccLogger = fccLogger;
                FdcCommunicator<T>.fccLogger = fccLogger;
                DebugLogger.logger = fccLogger;
            }

            this.parser = parser;
            this.fdcServerIpAddress = fdcServerIpAddress;
            this.clientId = clientId;

        }

        public Task<bool> Start()
        {
            if (0 == Interlocked.CompareExchange(ref this.isStarted, 1, 0))
            {
                try
                {
                    this.SetupFccClientConnectionInBackground();
                    return Task.FromResult(true);
                }
                catch (Exception exxx)
                {
                    return Task.FromResult(false);
                }
            }

            return Task.FromResult(false);
        }

        private void OnFccDataReceived(object sender, FccDataReceivedEventArgs e)
        {
            lock (syncObj)
            {
                var safe = this.OnDataReceived;
                var eventArg = new CommunicatorEventArg<object, T>();
                eventArg.Message = this.parser.Deserialize(e.Message);
                fccLogger.LogDebug(string.Format("OnFccDataReceived, ThreadId {0}", Thread.CurrentThread.ManagedThreadId));
                safe?.Invoke(this, eventArg);
            }
        }

        /// <summary>
        /// connect to remote pump, FC as the client side.
        /// </summary>
        /// <returns></returns>
        private void SetupFccClientConnectionInBackground()
        {
            var msgRouterServerIPEndPoint = new IPEndPoint(IPAddress.Parse(fdcServerIpAddress), FUSION_MESSAGE_ROUTER_PORT);
            var msgRouterClient = new MessageRouterClient(msgRouterServerIPEndPoint, CRYPT_FORMAT, MESSAGE_VERSION);
            var msgRouterComm = new MessageRouterCommunicator<T>(parser, msgRouterClient);
            msgRouterComm.OnDataReceived += OnFccDataReceived;
            msgRouterComm.Start();
            fdcComm = new FdcCommunicator<T>(parser, new MessageRouterClient(msgRouterServerIPEndPoint, CRYPT_FORMAT, MESSAGE_VERSION), fdcServerIpAddress, clientId.TrimEnd('.'));
            fdcComm.OnDataReceived += OnFccDataReceived;
            fdcComm.Start();
        }

        public void Dispose()
        {
            this.disposed = true;
        }

        public bool Write(T message)
        {
            var fcmMessage = message as Global_Pump_Fdc.MessageEntity.FccMessageBase;
            var parameterDic = fcmMessage.Parameters as Dictionary<string, object>;
            string command = parameterDic["Command"].ToString();

            if (command == "Authorize")
            {
                fdcComm.AuthorizePumpAsync(parameterDic);
            }
            else if (command == "QueryTotalizer")
            {
                fdcComm.QueryTotalizer(parameterDic);
            }
            else if (command == "PriceUpdate")
            {
                fdcComm.SetFuelPrice(parameterDic);
            }

            return true;
        }

        public bool Write(T message, object extraControlParameter)
        {
            throw new NotImplementedException();
        }
    }

    public class FccDataReceivedEventArgs : EventArgs
    {
        private StringDictionary message;

        public FccDataReceivedEventArgs(StringDictionary message)
        {
            this.message = message;
        }

        public StringDictionary Message
        {
            get { return message; }
        }
    }
}