using System.Linq;
using Content.Shared.Administration.Logs;
using Content.Shared.Body;
using Content.Shared.Body.Components;
using Content.Shared.Body.Systems;
using Content.Shared.Chemistry;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.Components.SolutionManager;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Climbing.Systems;
using Content.Shared.Containers.ItemSlots;
using Content.Shared.Database;
using Content.Shared.DoAfter;
using Content.Shared.DragDrop;
using Content.Shared.Emag.Systems;
using Content.Shared.Examine;
using Content.Shared.FixedPoint;
using Content.Shared.Hands.EntitySystems;
using Content.Shared.Interaction;
using Content.Shared.MedicalScanner;
using Content.Shared.Mobs.Components;
using Content.Shared.Mobs.Systems;
using Content.Shared.Popups;
using Content.Shared.Power;
using Content.Shared.Standing;
using Content.Shared.Stunnable;
using Content.Shared.Tools.Systems;
using Content.Shared.UserInterface;
using Content.Shared.Verbs;
using Robust.Shared.Containers;
using Robust.Shared.Serialization;
using Robust.Shared.Timing;
namespace Content.Shared.Medical.Cryogenics;

public abstract partial class SharedCryoPodSystem : EntitySystem
{
    [Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
    [Dependency] protected readonly IGameTiming Timing = default!;
    [Dependency] private readonly ClimbSystem _climb = default!;
    [Dependency] private readonly EmagSystem _emag = default!;
    [Dependency] private readonly ItemSlotsSystem _itemSlots = default!;
    [Dependency] private readonly MobStateSystem _mobState = default!;
    [Dependency] private readonly ReactiveSystem _reactive = default!;
    [Dependency] protected readonly SharedAppearanceSystem Appearance = default!;
    [Dependency] private readonly SharedBloodstreamSystem _bloodstream = default!;
    [Dependency] private readonly SharedContainerSystem _container = default!;
    [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
    [Dependency] private readonly SharedHandsSystem _hands = default!;
    [Dependency] private readonly SharedPointLightSystem _light = default!;
    [Dependency] private readonly SharedPopupSystem _popup = default!;
    [Dependency] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
    [Dependency] private readonly SharedToolSystem _tool = default!;
    [Dependency] protected readonly SharedUserInterfaceSystem UI = default!;
    [Dependency] private readonly StandingStateSystem _standingState = default!;

    private EntityQuery<BloodstreamComponent> _bloodstreamQuery;
    private EntityQuery<ItemSlotsComponent> _itemSlotsQuery;
    private EntityQuery<FitsInDispenserComponent> _dispenserQuery;
    private EntityQuery<SolutionContainerManagerComponent> _solutionContainerQuery;


    public override void Initialize()
    {
        base.Initialize();

        SubscribeLocalEvent<CryoPodComponent, CanDropTargetEvent>(OnCryoPodCanDropOn);
        SubscribeLocalEvent<CryoPodComponent, ExaminedEvent>(OnExamined);
        SubscribeLocalEvent<CryoPodComponent, ComponentInit>(OnComponentInit);
        SubscribeLocalEvent<CryoPodComponent, GetVerbsEvent<AlternativeVerb>>(AddAlternativeVerbs);
        SubscribeLocalEvent<CryoPodComponent, GotEmaggedEvent>(OnEmagged);
        SubscribeLocalEvent<CryoPodComponent, CryoPodDragFinished>(OnDragFinished);
        SubscribeLocalEvent<CryoPodComponent, CryoPodPryFinished>(OnCryoPodPryFinished);
        SubscribeLocalEvent<CryoPodComponent, DragDropTargetEvent>(HandleDragDropOn);
        SubscribeLocalEvent<CryoPodComponent, InteractUsingEvent>(OnInteractUsing);
        SubscribeLocalEvent<CryoPodComponent, PowerChangedEvent>(OnPowerChanged);
        SubscribeLocalEvent<CryoPodComponent, ActivatableUIOpenAttemptEvent>(OnActivateUIAttempt);
        SubscribeLocalEvent<CryoPodComponent, EntRemovedFromContainerMessage>(OnEjected);
        SubscribeLocalEvent<CryoPodComponent, EntInsertedIntoContainerMessage>(OnBodyInserted);

        _bloodstreamQuery = GetEntityQuery<BloodstreamComponent>();
        _itemSlotsQuery = GetEntityQuery<ItemSlotsComponent>();
        _dispenserQuery = GetEntityQuery<FitsInDispenserComponent>();
        _solutionContainerQuery = GetEntityQuery<SolutionContainerManagerComponent>();

        InitializeInsideCryoPod();

        Subs.BuiEvents<CryoPodComponent>(CryoPodUiKey.Key, subs =>
        {
            subs.Event<BoundUIOpenedEvent>(OnBoundUiOpened);
            subs.Event<CryoPodSimpleUiMessage>(OnSimpleUiMessage);
            subs.Event<CryoPodInjectUiMessage>(OnInjectUiMessage);
        });
    }

    public override void Update(float frameTime)
    {
        base.Update(frameTime);

        var curTime = Timing.CurTime;
        var query = EntityQueryEnumerator<ActiveCryoPodComponent, CryoPodComponent>();

        while (query.MoveNext(out var uid, out _, out var cryoPod))
        {
            if (curTime < cryoPod.NextInjectionTime)
                continue;

            cryoPod.NextInjectionTime += cryoPod.BeakerTransferTime;
            Dirty(uid, cryoPod);
            UpdateInjection((uid, cryoPod));
        }
    }

    private void UpdateInjection(Entity<CryoPodComponent> entity)
    {
        var patient = entity.Comp.BodyContainer.ContainedEntity;

        if (patient == null
            || !_solutionContainerQuery.TryComp(entity, out var podSolutionManager)
            || !_solutionContainer.TryGetSolution(
                    (entity.Owner, podSolutionManager),
                    CryoPodComponent.InjectionBufferSolutionName,
                    out var injectingSolution,
                    out _)
            || !_bloodstreamQuery.TryComp(patient, out var bloodstream))
        {
            return;
        }

        // DeltaV - Cryotubes Inject Evenly
        var solutionToInject = entity.Comp.InjectEvenly ? _solutionContainer.SplitSolutionReagentsEvenly(injectingSolution.Value, entity.Comp.BeakerTransferAmount)
            : _solutionContainer.SplitSolution(injectingSolution.Value, entity.Comp.BeakerTransferAmount);
        // END DeltaV

        if (solutionToInject.Volume > 0)
        {
            _bloodstream.TryAddToBloodstream((patient.Value, bloodstream), solutionToInject);
            _reactive.DoEntityReaction(patient.Value, solutionToInject, ReactionMethod.Injection);
        }
    }

    private void HandleDragDropOn(Entity<CryoPodComponent> ent, ref DragDropTargetEvent args)
    {
        if (ent.Comp.BodyContainer.ContainedEntity != null)
            return;

        var doAfterArgs = new DoAfterArgs(EntityManager, args.User, ent.Comp.EntryDelay, new CryoPodDragFinished(), ent, target: args.Dragged, used: ent)
        {
            BreakOnDamage = true,
            BreakOnMove = true,
            NeedHand = false,
        };
        _doAfter.TryStartDoAfter(doAfterArgs);
        args.Handled = true;
    }

    private void OnDragFinished(Entity<CryoPodComponent> ent, ref CryoPodDragFinished args)
    {
        if (args.Cancelled || args.Handled || args.Args.Target == null)
            return;

        if (InsertBody(ent.Owner, args.Args.Target.Value, ent.Comp))
        {
            _adminLogger.Add(LogType.Action, LogImpact.Medium,
                $"{ToPrettyString(args.User)} inserted {ToPrettyString(args.Args.Target.Value)} into {ToPrettyString(ent.Owner)}");
        }
        args.Handled = true;
    }

    private void OnActivateUIAttempt(Entity<CryoPodComponent> ent, ref ActivatableUIOpenAttemptEvent args)
    {
        if (args.Cancelled)
            return;

        var containedEntity = ent.Comp.BodyContainer.ContainedEntity;
        if (containedEntity == args.User)
            args.Cancel();
    }

    private void OnInteractUsing(Entity<CryoPodComponent> ent, ref InteractUsingEvent args)
    {
        if (args.Handled || !ent.Comp.Locked || ent.Comp.BodyContainer.ContainedEntity == null)
            return;

        args.Handled = _tool.UseTool(args.Used, args.User, ent.Owner, ent.Comp.PryDelay, ent.Comp.UnlockToolQuality, new CryoPodPryFinished());
    }

    private void OnCryoPodPryFinished(EntityUid uid, CryoPodComponent cryoPodComponent, CryoPodPryFinished args)
    {
        if (args.Cancelled)
            return;

        var ejected = EjectBody(uid, cryoPodComponent);
        if (ejected != null)
            _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(ejected.Value)} pried out of {ToPrettyString(uid)} by {ToPrettyString(args.User)}");
    }

    private void OnPowerChanged(Entity<CryoPodComponent> ent, ref PowerChangedEvent args)
    {
        // Needed to avoid adding/removing components on a deleted entity
        if (Terminating(ent))
            return;

        if (args.Powered)
        {
            EnsureComp<ActiveCryoPodComponent>(ent);
            ent.Comp.NextInjectionTime = Timing.CurTime + ent.Comp.BeakerTransferTime;
            Dirty(ent);
        }
        else
        {
            RemComp<ActiveCryoPodComponent>(ent);
            UI.CloseUi(ent.Owner, HealthAnalyzerUiKey.Key);
        }

        UpdateAppearance(ent.Owner, ent.Comp);
    }

    private void OnExamined(Entity<CryoPodComponent> entity, ref ExaminedEvent args)
    {
        var container = _itemSlots.GetItemOrNull(entity.Owner, entity.Comp.SolutionContainerName);
        if (args.IsInDetailsRange && container != null && _solutionContainer.TryGetFitsInDispenser(container.Value, out _, out var containerSolution))
        {
            using (args.PushGroup(nameof(CryoPodComponent)))
            {
                args.PushMarkup(Loc.GetString("cryo-pod-examine", ("beaker", Name(container.Value))));
                if (containerSolution.Volume == 0)
                {
                    args.PushMarkup(Loc.GetString("cryo-pod-empty-beaker"));
                }
            }
        }
    }

    private void OnCryoPodCanDropOn(EntityUid uid, CryoPodComponent component, ref CanDropTargetEvent args)
    {
        if (args.Handled)
            return;

        args.CanDrop = HasComp<BodyComponent>(args.Dragged);
        args.Handled = true;
    }

    private void OnComponentInit(EntityUid uid, CryoPodComponent cryoPodComponent, ComponentInit args)
    {
        cryoPodComponent.BodyContainer = _container.EnsureContainer<ContainerSlot>(uid, CryoPodComponent.BodyContainerName);
    }

    private void UpdateAppearance(EntityUid uid, CryoPodComponent? cryoPod = null, AppearanceComponent? appearance = null)
    {
        if (!Resolve(uid, ref cryoPod))
            return;

        var cryoPodEnabled = HasComp<ActiveCryoPodComponent>(uid);

        if (_light.TryGetLight(uid, out var light))
        {
            _light.SetEnabled(uid, cryoPodEnabled && cryoPod.BodyContainer?.ContainedEntity != null, light);
        }

        if (!Resolve(uid, ref appearance))
            return;

        Appearance.SetData(uid, CryoPodVisuals.ContainsEntity, cryoPod.BodyContainer?.ContainedEntity == null, appearance);
        Appearance.SetData(uid, CryoPodVisuals.IsOn, cryoPodEnabled, appearance);
    }

    public bool InsertBody(EntityUid uid, EntityUid target, CryoPodComponent cryoPodComponent)
    {
        if (cryoPodComponent.BodyContainer.ContainedEntity != null)
            return false;

        if (!HasComp<MobStateComponent>(target))
            return false;

        var xform = Transform(target);
        _container.Insert((target, xform), cryoPodComponent.BodyContainer);

        EnsureComp<InsideCryoPodComponent>(target);
        _standingState.Stand(target, force: true); // Force-stand the mob so that the cryo pod sprite overlays it fully

        UpdateAppearance(uid, cryoPodComponent);
        return true;
    }

    public void TryEjectBody(EntityUid uid, EntityUid userId, CryoPodComponent? cryoPodComponent)
    {
        if (!Resolve(uid, ref cryoPodComponent))
        {
            return;
        }

        if (cryoPodComponent.Locked)
        {
            _popup.PopupClient(Loc.GetString("cryo-pod-locked"), uid, userId);
            return;
        }

        var ejected = EjectBody(uid, cryoPodComponent);
        if (ejected != null)
            _adminLogger.Add(LogType.Action, LogImpact.Medium, $"{ToPrettyString(ejected.Value)} ejected from {ToPrettyString(uid)} by {ToPrettyString(userId)}");
    }

    /// <summary>
    /// Ejects the contained body
    /// </summary>
    /// <param name="uid">The cryopod entity</param>
    /// <param name="cryoPodComponent">Cryopod component of <see cref="uid"/></param>
    /// <returns>Ejected entity</returns>
    public EntityUid? EjectBody(EntityUid uid, CryoPodComponent? cryoPodComponent)
    {
        if (!Resolve(uid, ref cryoPodComponent))
            return null;

        if (cryoPodComponent.BodyContainer.ContainedEntity is not { Valid: true } contained)
            return null;

        _container.Remove(contained, cryoPodComponent.BodyContainer);
        // InsideCryoPodComponent is removed automatically in its EntGotRemovedFromContainerMessage listener
        // RemComp<InsideCryoPodComponent>(contained);

        // Restore the correct position of the patient. Checking the components manually feels hacky, but I did not find a better way for now.
        if (HasComp<KnockedDownComponent>(contained) || _mobState.IsIncapacitated(contained))
            _standingState.Down(contained);
        else
            _standingState.Stand(contained);

        _climb.ForciblySetClimbing(contained, uid);
        UpdateAppearance(uid, cryoPodComponent);
        return contained;
    }

    public void TryEjectBeaker(Entity<CryoPodComponent> cryoPod, EntityUid? user)
    {
        if (_itemSlots.TryEject(cryoPod.Owner, cryoPod.Comp.SolutionContainerName, user, out var beaker)
            && user != null)
        {
            // Eject the beaker to the user's hands if possible.
            _hands.PickupOrDrop(user.Value, beaker.Value);
        }
    }

    /// <summary>
    /// Transfers reagents from the cryopod beaker into the injection buffer.
    /// </summary>
    /// <param name="cryoPod">The cryopod entity</param>
    /// <param name="transferAmount">
    /// The amount of reagents that will be transferred.
    /// If less reagents are available, however much is available will be transferred.
    /// </param>
    public void TryInject(Entity<CryoPodComponent> cryoPod, FixedPoint2 transferAmount)
    {
        var patient = cryoPod.Comp.BodyContainer.ContainedEntity;
        if (patient == null)
            return; // Refuse to inject if there is no patient.

        var beaker = _itemSlots.GetItemOrNull(cryoPod, cryoPod.Comp.SolutionContainerName);

        if (beaker == null
            || !beaker.Value.Valid
            || !_dispenserQuery.TryComp(beaker, out var fitsInDispenserComponent)
            || !_solutionContainerQuery.TryComp(beaker, out var beakerSolutionManager)
            || !_solutionContainerQuery.TryComp(cryoPod, out var podSolutionManager)
            || !_solutionContainer.TryGetFitsInDispenser(
                    (beaker.Value, fitsInDispenserComponent, beakerSolutionManager),
                    out var beakerSolution,
                    out _)
            || !_solutionContainer.TryGetSolution(
                    (cryoPod.Owner, podSolutionManager),
                    CryoPodComponent.InjectionBufferSolutionName,
                    out var injectionSolutionComp,
                    out var injectionSolution))
        {
            return;
        }

        if (injectionSolution.AvailableVolume == 0)
            return;

        var amountToTransfer = FixedPoint2.Min(transferAmount, injectionSolution.AvailableVolume);
        var solution = _solutionContainer.SplitSolution(beakerSolution.Value, amountToTransfer);
        _solutionContainer.TryAddSolution(injectionSolutionComp.Value, solution);
    }

    public void ClearInjectionBuffer(Entity<CryoPodComponent> cryoPod)
    {
        if (_solutionContainerQuery.TryComp(cryoPod, out var podSolutionManager)
            && _solutionContainer.TryGetSolution(
                    (cryoPod.Owner, podSolutionManager),
                    CryoPodComponent.InjectionBufferSolutionName,
                    out var injectingSolution,
                    out _))
        {
            _solutionContainer.RemoveAllSolution(injectingSolution.Value);
        }
    }

    protected (FixedPoint2? capacity, List<ReagentQuantity>? reagents) GetBeakerInfo(Entity<CryoPodComponent> entity)
    {
        if (!_itemSlotsQuery.TryComp(entity, out var itemSlotsComponent))
            return (null, null);

        var beaker = _itemSlots.GetItemOrNull(
            entity.Owner,
            entity.Comp.SolutionContainerName,
            itemSlotsComponent
        );

        if (beaker == null
            || !beaker.Value.Valid
            || !_dispenserQuery.TryComp(beaker, out var fitsInDispenserComponent)
            || !_solutionContainerQuery.TryComp(beaker, out var solutionContainerManagerComponent)
            || !_solutionContainer.TryGetFitsInDispenser(
                    (beaker.Value, fitsInDispenserComponent, solutionContainerManagerComponent),
                    out var containerSolution,
                    out _))
            return (null, null);

        var capacity = containerSolution.Value.Comp.Solution.MaxVolume;
        var reagents = containerSolution.Value.Comp.Solution.Contents
            .Select(reagent => new ReagentQuantity(reagent.Reagent, reagent.Quantity))
            .ToList();

        return (capacity, reagents);
    }

    protected List<ReagentQuantity>? GetInjectingReagents(Entity<CryoPodComponent> entity)
    {
        if (!_solutionContainerQuery.TryComp(entity, out var solutionManager)
            || !_solutionContainer.TryGetSolution(
                    (entity.Owner, solutionManager),
                    CryoPodComponent.InjectionBufferSolutionName,
                    out var injectingSolution,
                    out _))
            return null;

        return injectingSolution.Value.Comp.Solution.Contents
            .Select(reagent => new ReagentQuantity(reagent.Reagent, reagent.Quantity))
            .ToList();
    }

    protected void AddAlternativeVerbs(EntityUid uid, CryoPodComponent cryoPodComponent, GetVerbsEvent<AlternativeVerb> args)
    {
        if (!args.CanAccess || !args.CanInteract)
            return;

        // Eject verb
        if (cryoPodComponent.BodyContainer.ContainedEntity != null)
        {
            args.Verbs.Add(new AlternativeVerb
            {
                Text = Loc.GetString("cryo-pod-verb-noun-occupant"),
                Category = VerbCategory.Eject,
                Priority = 1, // Promote to top to make ejecting the ALT-click action
                Act = () => TryEjectBody(uid, args.User, cryoPodComponent)
            });
        }
    }

    protected void OnEmagged(EntityUid uid, CryoPodComponent? cryoPodComponent, ref GotEmaggedEvent args)
    {
        if (!Resolve(uid, ref cryoPodComponent))
            return;

        if (!_emag.CompareFlag(args.Type, EmagType.Interaction))
            return;

        if (cryoPodComponent.PermaLocked && cryoPodComponent.Locked)
            return;

        cryoPodComponent.PermaLocked = true;
        cryoPodComponent.Locked = true;
        Dirty(uid, cryoPodComponent);
        args.Handled = true;
    }

    private void OnSimpleUiMessage(Entity<CryoPodComponent> cryoPod, ref CryoPodSimpleUiMessage msg)
    {
        switch (msg.Type)
        {
            case CryoPodSimpleUiMessage.MessageType.EjectPatient:
                TryEjectBody(cryoPod.Owner, msg.Actor, cryoPod.Comp);
                break;
            case CryoPodSimpleUiMessage.MessageType.EjectBeaker:
                TryEjectBeaker(cryoPod, msg.Actor);
                break;
        }

        UpdateUi(cryoPod);
    }

    private void OnInjectUiMessage(Entity<CryoPodComponent> cryoPod, ref CryoPodInjectUiMessage msg)
    {
        TryInject(cryoPod, msg.Quantity);
        UpdateUi(cryoPod);
    }

    private void OnBoundUiOpened(Entity<CryoPodComponent> cryoPod, ref BoundUIOpenedEvent args)
    {
        UpdateUi(cryoPod);
    }

    private void OnEjected(Entity<CryoPodComponent> cryoPod, ref EntRemovedFromContainerMessage args)
    {
        if (args.Container.ID == CryoPodComponent.BodyContainerName)
        {
            ClearInjectionBuffer(cryoPod);
        }

        UpdateUi(cryoPod);
    }

    private void OnBodyInserted(Entity<CryoPodComponent> cryoPod, ref EntInsertedIntoContainerMessage args)
    {
        if (args.Container.ID == CryoPodComponent.BodyContainerName)
        {
            UI.CloseUi(cryoPod.Owner, CryoPodUiKey.Key, args.Entity);
            ClearInjectionBuffer(cryoPod);
        }

        UpdateUi(cryoPod);
    }

    protected abstract void UpdateUi(Entity<CryoPodComponent> cryoPod);

    [Serializable, NetSerializable]
    public sealed partial class CryoPodPryFinished : SimpleDoAfterEvent;

    [Serializable, NetSerializable]
    public sealed partial class CryoPodDragFinished : SimpleDoAfterEvent;
}