// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.

using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Extensions.Color4Extensions;
using osu.Framework.Extensions.ObjectExtensions;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Colour;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Lines;
using osu.Framework.Layout;
using osu.Framework.Threading;
using osu.Framework.Utils;
using osu.Game.Configuration;
using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Skinning;
using osuTK;
using osuTK.Graphics;

namespace osu.Game.Screens.Play.HUD
{
    public partial class ArgonHealthDisplay : HealthDisplay, ISerialisableDrawable
    {
        public bool UsesFixedAnchor { get; set; }

        [SettingSource("Bar height")]
        public BindableFloat BarHeight { get; } = new BindableFloat(20)
        {
            MinValue = 0,
            MaxValue = 64,
            Precision = 1
        };

        [SettingSource("Use relative size")]
        public BindableBool UseRelativeSize { get; } = new BindableBool(true);

        private BarPath mainBar = null!;

        /// <summary>
        /// Used to show a glow at the end of the main bar, or red "damage" area when missing.
        /// </summary>
        private BarPath glowBar = null!;

        private BackgroundPath background = null!;

        private SliderPath barPath = null!;

        private static readonly Colour4 main_bar_colour = Colour4.White;
        private static readonly Colour4 main_bar_glow_colour = Color4Extensions.FromHex("#7ED7FD").Opacity(0.5f);

        private ScheduledDelegate? resetMissBarDelegate;

        private bool displayingMiss => resetMissBarDelegate != null;

        private readonly List<Vector2> missBarVertices = new List<Vector2>();
        private readonly List<Vector2> healthBarVertices = new List<Vector2>();

        private double glowBarValue;

        public double GlowBarValue
        {
            get => glowBarValue;
            set
            {
                if (glowBarValue == value)
                    return;

                glowBarValue = value;
                Scheduler.AddOnce(updatePathVertices);
            }
        }

        private double healthBarValue;

        public double HealthBarValue
        {
            get => healthBarValue;
            set
            {
                if (healthBarValue == value)
                    return;

                healthBarValue = value;
                Scheduler.AddOnce(updatePathVertices);
            }
        }

        public const float MAIN_PATH_RADIUS = 10f;

        private const float curve_start_offset = 70;
        private const float curve_end_offset = 40;
        private const float padding = MAIN_PATH_RADIUS * 2;
        private const float curve_smoothness = 10;

        private readonly LayoutValue drawSizeLayout = new LayoutValue(Invalidation.DrawSize);

        public ArgonHealthDisplay()
        {
            AddLayout(drawSizeLayout);

            // sane default width specification.
            // this only matters if the health display isn't part of the default skin
            // (in which case width will be set to 300 via `ArgonSkin.GetDrawableComponent()`),
            // and if the user hasn't applied their own modifications
            // (which are applied via `SerialisedDrawableInfo.ApplySerialisedInfo()`).
            Width = 0.98f;
        }

        [BackgroundDependencyLoader]
        private void load()
        {
            AutoSizeAxes = Axes.Y;

            InternalChild = new Container
            {
                AutoSizeAxes = Axes.Both,
                Children = new Drawable[]
                {
                    background = new BackgroundPath
                    {
                        PathRadius = MAIN_PATH_RADIUS,
                    },
                    glowBar = new BarPath
                    {
                        BarColour = Color4.White,
                        GlowColour = main_bar_glow_colour,
                        Blending = BlendingParameters.Additive,
                        Colour = ColourInfo.GradientHorizontal(Color4.White.Opacity(0.8f), Color4.White),
                        PathRadius = 40f,
                        // Kinda hacky, but results in correct positioning with increased path radius.
                        Margin = new MarginPadding(-30f),
                        GlowPortion = 0.9f,
                    },
                    mainBar = new BarPath
                    {
                        AutoSizeAxes = Axes.None,
                        RelativeSizeAxes = Axes.Both,
                        Blending = BlendingParameters.Additive,
                        BarColour = main_bar_colour,
                        GlowColour = main_bar_glow_colour,
                        PathRadius = MAIN_PATH_RADIUS,
                        GlowPortion = 0.6f,
                    },
                }
            };
        }

        private bool pendingMissAnimation;

        protected override void LoadComplete()
        {
            base.LoadComplete();

            HealthProcessor.NewJudgement += onNewJudgement;
            Current.BindValueChanged(onCurrentChanged, true);

            // we're about to set `RelativeSizeAxes` depending on the value of `UseRelativeSize`.
            // setting `RelativeSizeAxes` internally transforms absolute sizing to relative and back to keep the size the same,
            // but that is not what we want in this case, since the width at this point is valid in the *target* sizing mode.
            // to counteract this, store the numerical value here, and restore it after setting the correct initial relative sizing axes.
            float previousWidth = Width;
            UseRelativeSize.BindValueChanged(v => RelativeSizeAxes = v.NewValue ? Axes.X : Axes.None, true);
            Width = previousWidth;

            BarHeight.BindValueChanged(_ => updatePath(), true);
        }

        private void onNewJudgement(JudgementResult result) => pendingMissAnimation |= !result.IsHit;

        private void onCurrentChanged(ValueChangedEvent<double> valueChangedEvent)
            // schedule display updates one frame later to ensure we know the judgement result causing this change (if there is one).
            => Scheduler.AddOnce(updateDisplay);

        private void updateDisplay()
        {
            double newHealth = Current.Value;

            if (newHealth >= GlowBarValue)
                finishMissDisplay();

            double time = newHealth > GlowBarValue ? 500 : 250;

            // TODO: this should probably use interpolation in update.
            this.TransformTo(nameof(HealthBarValue), newHealth, time, Easing.OutQuint);

            if (pendingMissAnimation && newHealth < GlowBarValue)
                triggerMissDisplay();

            pendingMissAnimation = false;

            if (!displayingMiss)
                this.TransformTo(nameof(GlowBarValue), newHealth, time, Easing.OutQuint);
        }

        protected override void Update()
        {
            base.Update();

            if (!drawSizeLayout.IsValid)
            {
                updatePath();
                drawSizeLayout.Validate();
            }

            mainBar.Alpha = (float)Interpolation.DampContinuously(mainBar.Alpha, Current.Value > 0 ? 1 : 0, 40, Time.Elapsed);
            glowBar.Alpha = (float)Interpolation.DampContinuously(glowBar.Alpha, GlowBarValue > 0 ? 1 : 0, 40, Time.Elapsed);
        }

        protected override void FinishInitialAnimation(double value)
        {
            base.FinishInitialAnimation(value);
            this.TransformTo(nameof(HealthBarValue), value, 500, Easing.OutQuint);
            this.TransformTo(nameof(GlowBarValue), value, 250, Easing.OutQuint);
        }

        protected override void Flash()
        {
            base.Flash();

            mainBar.TransformTo(nameof(BarPath.GlowColour), main_bar_glow_colour.Opacity(0.8f))
                   .TransformTo(nameof(BarPath.GlowColour), main_bar_glow_colour, 300, Easing.OutQuint);

            if (!displayingMiss)
            {
                glowBar.TransformTo(nameof(BarPath.BarColour), Colour4.White, 30, Easing.OutQuint)
                       .Then()
                       .TransformTo(nameof(BarPath.BarColour), main_bar_colour, 1000, Easing.OutQuint);

                glowBar.TransformTo(nameof(BarPath.GlowColour), Colour4.White, 30, Easing.OutQuint)
                       .Then()
                       .TransformTo(nameof(BarPath.GlowColour), main_bar_glow_colour, 300, Easing.OutQuint);
            }
        }

        private void triggerMissDisplay()
        {
            resetMissBarDelegate?.Cancel();
            resetMissBarDelegate = null;

            this.Delay(500).Schedule(() =>
            {
                this.TransformTo(nameof(GlowBarValue), Current.Value, 300, Easing.OutQuint);
                finishMissDisplay();
            }, out resetMissBarDelegate);

            glowBar.TransformTo(nameof(BarPath.BarColour), new Colour4(255, 147, 147, 255), 100, Easing.OutQuint).Then()
                   .TransformTo(nameof(BarPath.BarColour), new Colour4(255, 93, 93, 255), 800, Easing.OutQuint);

            glowBar.TransformTo(nameof(BarPath.GlowColour), new Colour4(253, 0, 0, 255).Lighten(0.2f))
                   .TransformTo(nameof(BarPath.GlowColour), new Colour4(253, 0, 0, 255), 800, Easing.OutQuint);
        }

        private void finishMissDisplay()
        {
            if (!displayingMiss)
                return;

            if (Current.Value > 0)
            {
                glowBar.TransformTo(nameof(BarPath.BarColour), main_bar_colour, 300, Easing.In);
                glowBar.TransformTo(nameof(BarPath.GlowColour), main_bar_glow_colour, 300, Easing.In);
            }

            resetMissBarDelegate?.Cancel();
            resetMissBarDelegate = null;
        }

        private void updatePath()
        {
            float usableWidth = DrawWidth - padding;

            if (usableWidth < 0) enforceMinimumWidth();

            // the display starts curving at `curve_start_offset` units from the right and ends curving at `curve_end_offset`.
            // to ensure that the curve is symmetric when it starts being narrow enough, add a `curve_end_offset` to the left side too.
            const float rescale_cutoff = curve_start_offset + curve_end_offset;

            float barLength = Math.Max(DrawWidth - padding, rescale_cutoff);
            float curveStart = barLength - curve_start_offset;
            float curveEnd = barLength - curve_end_offset;

            Vector2 diagonalDir = (new Vector2(curveEnd, BarHeight.Value) - new Vector2(curveStart, 0)).Normalized();

            barPath = new SliderPath(new[]
            {
                new PathControlPoint(new Vector2(0, 0), PathType.LINEAR),
                new PathControlPoint(new Vector2(curveStart - curve_smoothness, 0), PathType.BEZIER),
                new PathControlPoint(new Vector2(curveStart, 0)),
                new PathControlPoint(new Vector2(curveStart, 0) + diagonalDir * curve_smoothness, PathType.LINEAR),
                new PathControlPoint(new Vector2(curveEnd, BarHeight.Value) - diagonalDir * curve_smoothness, PathType.BEZIER),
                new PathControlPoint(new Vector2(curveEnd, BarHeight.Value)),
                new PathControlPoint(new Vector2(curveEnd + curve_smoothness, BarHeight.Value), PathType.LINEAR),
                new PathControlPoint(new Vector2(barLength, BarHeight.Value)),
            });

            if (DrawWidth - padding < rescale_cutoff)
                rescalePathProportionally();

            List<Vector2> vertices = new List<Vector2>();
            barPath.GetPathToProgress(vertices, 0.0, 1.0);

            background.Vertices = vertices;
            mainBar.Vertices = vertices;
            glowBar.Vertices = vertices;

            updatePathVertices();

            void enforceMinimumWidth()
            {
                // Switch to absolute in order to be able to define a minimum width.
                // Then switch back is required. Framework will handle the conversion for us.
                Axes relativeAxes = RelativeSizeAxes;
                RelativeSizeAxes = Axes.None;

                Width = padding;

                RelativeSizeAxes = relativeAxes;
            }

            void rescalePathProportionally()
            {
                foreach (var point in barPath.ControlPoints)
                    point.Position = new Vector2(point.Position.X / barLength * (DrawWidth - padding), point.Position.Y);
            }
        }

        private void updatePathVertices()
        {
            barPath.GetPathToProgress(healthBarVertices, 0.0, healthBarValue);
            barPath.GetPathToProgress(missBarVertices, healthBarValue, Math.Max(glowBarValue, healthBarValue));

            if (healthBarVertices.Count == 0)
                healthBarVertices.Add(Vector2.Zero);

            if (missBarVertices.Count == 0)
                missBarVertices.Add(Vector2.Zero);

            glowBar.Vertices = missBarVertices.Select(v => v - missBarVertices[0]).ToList();
            glowBar.Position = missBarVertices[0];

            mainBar.Vertices = healthBarVertices.Select(v => v - healthBarVertices[0]).ToList();
            mainBar.Position = healthBarVertices[0];
        }

        protected override void Dispose(bool isDisposing)
        {
            base.Dispose(isDisposing);

            if (HealthProcessor.IsNotNull())
                HealthProcessor.NewJudgement -= onNewJudgement;
        }

        private partial class BackgroundPath : SmoothPath
        {
            protected override Color4 ColourAt(float position)
            {
                if (position <= 0.16f)
                    return Color4.White.Opacity(0.8f);

                return Interpolation.ValueAt(position,
                    Color4.White.Opacity(0.8f),
                    Color4.Black.Opacity(0.2f),
                    -0.5f, 1f, Easing.OutQuint);
            }
        }

        private partial class BarPath : SmoothPath
        {
            private Colour4 barColour;

            public Colour4 BarColour
            {
                get => barColour;
                set
                {
                    if (barColour == value)
                        return;

                    barColour = value;
                    InvalidateTexture();
                }
            }

            private Colour4 glowColour;

            public Colour4 GlowColour
            {
                get => glowColour;
                set
                {
                    if (glowColour == value)
                        return;

                    glowColour = value;
                    InvalidateTexture();
                }
            }

            public float GlowPortion { get; init; }

            protected override Color4 ColourAt(float position)
            {
                if (position >= GlowPortion)
                    return BarColour;

                return Interpolation.ValueAt(position, Colour4.Black.Opacity(0.0f), GlowColour, 0.0, GlowPortion, Easing.InQuint);
            }
        }
    }
}