#nullable enable

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using Barotrauma.Extensions;
using Barotrauma.Networking;

namespace Barotrauma
{
    internal partial class MedicalClinic
    {
        public enum RequestResult
        {
            Undecided,
            Success,
            Error,
            Timeout
        }

        public readonly struct RequestAction<T>
        {
            public readonly Action<T> Callback;
            public readonly DateTimeOffset Timeout;

            public RequestAction(Action<T> callback, DateTimeOffset timeout)
            {
                Callback = callback;
                Timeout = timeout;
            }
        }

        public readonly struct AfflictionRequest
        {
            public readonly RequestResult Result;
            public readonly ImmutableArray<NetAffliction> Afflictions;

            public AfflictionRequest(RequestResult result, ImmutableArray<NetAffliction> afflictions)
            {
                Result = result;
                Afflictions = afflictions;
            }
        }

        public readonly struct PendingRequest
        {
            public readonly RequestResult Result;
            public readonly ImmutableArray<NetCrewMember> CrewMembers;

            public PendingRequest(RequestResult result, ImmutableArray<NetCrewMember> crewMembers)
            {
                Result = result;
                CrewMembers = crewMembers;
            }
        }

        public readonly struct CallbackOnlyRequest
        {
            public readonly RequestResult Result;

            public CallbackOnlyRequest(RequestResult result)
            {
                Result = result;
            }
        }

        public readonly struct HealRequest
        {
            public readonly RequestResult Result;
            public readonly HealRequestResult HealResult;

            public HealRequest(RequestResult result, HealRequestResult healResult)
            {
                Result = result;
                HealResult = healResult;
            }
        }

        private readonly List<RequestAction<AfflictionRequest>> afflictionRequests = new List<RequestAction<AfflictionRequest>>();
        private readonly List<RequestAction<PendingRequest>> pendingHealRequests = new List<RequestAction<PendingRequest>>();
        private readonly List<RequestAction<CallbackOnlyRequest>> clearAllRequests = new List<RequestAction<CallbackOnlyRequest>>();
        private readonly List<RequestAction<HealRequest>> healAllRequests = new List<RequestAction<HealRequest>>();
        private readonly List<RequestAction<CallbackOnlyRequest>> addRequests = new List<RequestAction<CallbackOnlyRequest>>();
        private readonly List<RequestAction<CallbackOnlyRequest>> removeRequests = new List<RequestAction<CallbackOnlyRequest>>();

        public void RequestAfflictions(CharacterInfo info, Action<AfflictionRequest> onReceived)
        {
            if (GameMain.IsSingleplayer)
            {
#if DEBUG && LINUX
                if (Screen.Selected is TestScreen)
                {
                    onReceived.Invoke(new AfflictionRequest(RequestResult.Success, TestAfflictions.ToImmutableArray()));
                    return;
                }
#endif

                if (!(info is { Character: { CharacterHealth: { } health } }))
                {
                    onReceived.Invoke(new AfflictionRequest(RequestResult.Error, ImmutableArray<NetAffliction>.Empty));
                    return;
                }

                ImmutableArray<NetAffliction> pendingAfflictions = GetAllAfflictions(health).ToImmutableArray();
                onReceived.Invoke(new AfflictionRequest(RequestResult.Success, pendingAfflictions));
                return;
            }

            afflictionRequests.Add(new RequestAction<AfflictionRequest>(onReceived, GetTimeout()));
            SendAfflictionRequest(info);
        }

        public void RequestLatestPending(Action<PendingRequest> onReceived)
        {
            // no need to worry about syncing when there's only one pair of eyes capable of looking at the UI
            if (GameMain.IsSingleplayer) { return; }

            pendingHealRequests.Add(new RequestAction<PendingRequest>(onReceived, GetTimeout()));
            SendPendingRequest();
        }

        public void Update(float deltaTime)
        {
            DateTimeOffset now = DateTimeOffset.Now;
            UpdateQueue(afflictionRequests, now, onTimeout: callback => { callback(new AfflictionRequest(RequestResult.Timeout, ImmutableArray<NetAffliction>.Empty)); });
            UpdateQueue(pendingHealRequests, now, onTimeout: callback => { callback(new PendingRequest(RequestResult.Timeout, ImmutableArray<NetCrewMember>.Empty)); });
            UpdateQueue(healAllRequests, now, onTimeout: callback => { callback(new HealRequest(RequestResult.Timeout, HealRequestResult.Unknown)); });
            UpdateQueue(clearAllRequests, now, onTimeout: CallbackOnlyTimeout);
            UpdateQueue(addRequests, now, onTimeout: CallbackOnlyTimeout);
            UpdateQueue(removeRequests, now, onTimeout: CallbackOnlyTimeout);

            void CallbackOnlyTimeout(Action<CallbackOnlyRequest> callback) { callback(new CallbackOnlyRequest(RequestResult.Timeout)); }
        }

        public bool IsAfflictionPending(NetCrewMember character, NetAffliction affliction)
        {
            foreach (NetCrewMember crewMember in PendingHeals)
            {
                if (!crewMember.CharacterEquals(character)) { continue; }

                return crewMember.Afflictions.Any(a => a.AfflictionEquals(affliction));
            }

            return false;
        }

        private static bool TryDequeue<T>(List<RequestAction<T>> requestQueue, out Action<T> result)
        {
            RequestAction<T>? first = requestQueue.FirstOrNull();
            if (!(first is { } action))
            {
                result = _ => { };
                return false;
            }

            requestQueue.Remove(action);
            result = action.Callback;
            return true;
        }

        private static void UpdateQueue<T>(List<RequestAction<T>> requestQueue, DateTimeOffset now, Action<Action<T>> onTimeout)
        {
            HashSet<RequestAction<T>>? removals = null;
            foreach (RequestAction<T> action in requestQueue)
            {
                if (action.Timeout < now)
                {
                    onTimeout.Invoke(action.Callback);

                    removals ??= new HashSet<RequestAction<T>>();
                    removals.Add(action);
                }
            }

            if (removals is null) { return; }

            foreach (RequestAction<T> action in removals)
            {
                requestQueue.Remove(action);
            }
        }

        private void OnMoneyChanged(WalletChangedEvent e)
        {
            if (e.Wallet.IsOwnWallet) { OnUpdate?.Invoke(); }
        }

        // if you have more than 5000 ping there are probably more important things to worry about but hey just in case
        private static DateTimeOffset GetTimeout() => DateTimeOffset.Now.AddSeconds(5).AddMilliseconds(GetPing());

        private static int GetPing()
        {
            if (GameMain.IsSingleplayer || !(GameMain.Client?.Name is { } ownName) || !(GameMain.NetworkMember?.ConnectedClients is { } clients)) { return 0; }

            return (from client in clients where client.Name == ownName select client.Ping).FirstOrDefault();
        }

        public void HealAllButtonAction(Action<HealRequest> onReceived)
        {
            if (GameMain.IsSingleplayer)
            {
                HealRequestResult result = HealAllPending();
                onReceived(new HealRequest(RequestResult.Success, HealAllPending()));
                if (result == HealRequestResult.Success)
                {
                    OnUpdate?.Invoke();
                }

                return;
            }

            if (campaign?.CampaignUI?.MedicalClinic is { } ui)
            {
                ui.ClosePopup();
            }

            healAllRequests.Add(new RequestAction<HealRequest>(onReceived, GetTimeout()));
            ClientSend(null, NetworkHeader.HEAL_PENDING, DeliveryMethod.Reliable);
        }

        public void ClearAllButtonAction(Action<CallbackOnlyRequest> onReceived)
        {
            if (GameMain.IsSingleplayer)
            {
                ClearPendingHeals();
                onReceived(new CallbackOnlyRequest(RequestResult.Success));
                OnUpdate?.Invoke();
                return;
            }

            clearAllRequests.Add(new RequestAction<CallbackOnlyRequest>(onReceived, GetTimeout()));
            ClientSend(null, NetworkHeader.CLEAR_PENDING, DeliveryMethod.Reliable);
        }

        private void ClearRequstReceived()
        {
            ClearPendingHeals();
            if (TryDequeue(clearAllRequests, out var callback))
            {
                callback(new CallbackOnlyRequest(RequestResult.Success));
            }
            OnUpdate?.Invoke();
        }

        private void HealRequestReceived(IReadMessage inc)
        {
            NetHealRequest request = INetSerializableStruct.Read<NetHealRequest>(inc);

            if (request.Result == HealRequestResult.Success)
            {
                HealAllPending(force: true);
            }

            if (TryDequeue(healAllRequests, out var callback))
            {
                callback(new HealRequest(RequestResult.Success, request.Result));
            }

            OnUpdate?.Invoke();
        }

        public void AddPendingButtonAction(NetCrewMember crewMember, Action<CallbackOnlyRequest> onReceived)
        {
            if (GameMain.IsSingleplayer)
            {
                InsertPendingCrewMember(crewMember);
                onReceived(new CallbackOnlyRequest(RequestResult.Success));
                OnUpdate?.Invoke();
                return;
            }

            addRequests.Add(new RequestAction<CallbackOnlyRequest>(onReceived, GetTimeout()));
            ClientSend(crewMember, NetworkHeader.ADD_PENDING, DeliveryMethod.Reliable);
        }

        public void RemovePendingButtonAction(NetCrewMember crewMember, NetAffliction affliction, Action<CallbackOnlyRequest> onReceived)
        {
            if (GameMain.IsSingleplayer)
            {
                RemovePendingAffliction(crewMember, affliction);
                onReceived(new CallbackOnlyRequest(RequestResult.Success));
                OnUpdate?.Invoke();
                return;
            }

            INetSerializableStruct removedAffliction = new NetRemovedAffliction
            {
                CrewMember = crewMember,
                Affliction = affliction
            };

            removeRequests.Add(new RequestAction<CallbackOnlyRequest>(onReceived, GetTimeout()));
            ClientSend(removedAffliction, NetworkHeader.REMOVE_PENDING, DeliveryMethod.Reliable);
        }

        private void NewAdditonReceived(IReadMessage inc, MessageFlag flag)
        {
            NetCrewMember crewMember = INetSerializableStruct.Read<NetCrewMember>(inc);
            InsertPendingCrewMember(crewMember);
            if (flag == MessageFlag.Response && TryDequeue(addRequests, out var callback))
            {
                callback(new CallbackOnlyRequest(RequestResult.Success));
            }
            OnUpdate?.Invoke();
        }

        private void NewRemovalReceived(IReadMessage inc, MessageFlag flag)
        {
            NetRemovedAffliction removed = INetSerializableStruct.Read<NetRemovedAffliction>(inc);
            RemovePendingAffliction(removed.CrewMember, removed.Affliction);
            if (flag == MessageFlag.Response && TryDequeue(removeRequests, out var callback))
            {
                callback(new CallbackOnlyRequest(RequestResult.Success));
            }
            OnUpdate?.Invoke();
        }

        private static void SendAfflictionRequest(CharacterInfo info)
        {
            INetSerializableStruct crewMember = new NetCrewMember
            {
                CharacterInfo = info,
                Afflictions = Array.Empty<NetAffliction>()
            };

            ClientSend(crewMember, NetworkHeader.REQUEST_AFFLICTIONS, DeliveryMethod.Unreliable);
        }

        private static void SendPendingRequest()
        {
            ClientSend(null, NetworkHeader.REQUEST_PENDING, DeliveryMethod.Reliable);
        }

        private void AfflictionRequestReceived(IReadMessage inc)
        {
            NetCrewMember crewMember = INetSerializableStruct.Read<NetCrewMember>(inc);
            if (TryDequeue(afflictionRequests, out var callback))
            {
                RequestResult result = crewMember.CharacterInfoID == 0 ? RequestResult.Error : RequestResult.Success;
                callback(new AfflictionRequest(result, crewMember.Afflictions.ToImmutableArray()));
            }
        }

        private void PendingRequestReceived(IReadMessage inc)
        {
            NetPendingCrew pendingCrew = INetSerializableStruct.Read<NetPendingCrew>(inc);
            if (TryDequeue(pendingHealRequests, out var callback))
            {
                callback(new PendingRequest(RequestResult.Success, pendingCrew.CrewMembers.ToImmutableArray()));
            }
        }

        private static IWriteMessage StartSending()
        {
            IWriteMessage writeMessage = new WriteOnlyMessage();
            writeMessage.WriteByte((byte)ClientPacketHeader.MEDICAL);
            return writeMessage;
        }

        private static void ClientSend(INetSerializableStruct? netStruct, NetworkHeader header, DeliveryMethod deliveryMethod)
        {
            IWriteMessage msg = StartSending();
            msg.WriteByte((byte)header);
            netStruct?.Write(msg);
            GameMain.Client.ClientPeer?.Send(msg, deliveryMethod);
        }

        public void ClientRead(IReadMessage inc)
        {
            NetworkHeader header = (NetworkHeader)inc.ReadByte();
            MessageFlag flag = (MessageFlag)inc.ReadByte();

            switch (header)
            {
                case NetworkHeader.REQUEST_AFFLICTIONS:
                    AfflictionRequestReceived(inc);
                    break;
                case NetworkHeader.REQUEST_PENDING:
                    PendingRequestReceived(inc);
                    break;
                case NetworkHeader.ADD_PENDING:
                    NewAdditonReceived(inc, flag);
                    break;
                case NetworkHeader.REMOVE_PENDING:
                    NewRemovalReceived(inc, flag);
                    break;
                case NetworkHeader.HEAL_PENDING:
                    HealRequestReceived(inc);
                    break;
                case NetworkHeader.CLEAR_PENDING:
                    ClearRequstReceived();
                    break;
            }
        }
    }
}