// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

using System;
using System.Linq;
using OpenTK;
using osu.Game.Rulesets.Osu.Objects;

namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
{
    /// <summary>
    /// A wrapper around <see cref="OsuHitObject"/> extending it with additional data required for difficulty calculation.
    /// </summary>
    public class OsuDifficultyHitObject
    {
        /// <summary>
        /// The <see cref="OsuHitObject"/> this <see cref="OsuDifficultyHitObject"/> refers to.
        /// </summary>
        public OsuHitObject BaseObject { get; }

        /// <summary>
        /// Normalized distance from the <see cref="OsuHitObject.StackedPosition"/> of the previous <see cref="OsuDifficultyHitObject"/>.
        /// </summary>
        public double Distance { get; private set; }

        /// <summary>
        /// Milliseconds elapsed since the StartTime of the previous <see cref="OsuDifficultyHitObject"/>.
        /// </summary>
        public double DeltaTime { get; private set; }

        /// <summary>
        /// Number of milliseconds until the <see cref="OsuDifficultyHitObject"/> has to be hit.
        /// </summary>
        public double TimeUntilHit { get; set; }

        private const int normalized_radius = 52;

        private readonly double timeRate;

        private readonly OsuHitObject[] t;

        /// <summary>
        /// Initializes the object calculating extra data required for difficulty calculation.
        /// </summary>
        public OsuDifficultyHitObject(OsuHitObject[] triangle, double timeRate)
        {
            this.timeRate = timeRate;

            t = triangle;
            BaseObject = t[0];
            setDistances();
            setTimingValues();
            // Calculate angle here
        }

        private void setDistances()
        {
            // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
            double scalingFactor = normalized_radius / BaseObject.Radius;
            if (BaseObject.Radius < 30)
            {
                double smallCircleBonus = Math.Min(30 - BaseObject.Radius, 5) / 50;
                scalingFactor *= 1 + smallCircleBonus;
            }

            Vector2 lastCursorPosition = t[1].StackedPosition;

            var lastSlider = t[1] as Slider;
            if (lastSlider != null)
            {
                if (lastSlider.CursorPosition == null)
                {
                    float approxFollowCircleRadius = (float)(lastSlider.Radius * scalingFactor * 3);

                    var computeVertex = new Action<double>(t =>
                    {
                        var diff = lastSlider.PositionAt(t) - lastCursorPosition;
                        float dist = diff.Length;

                        if (dist > approxFollowCircleRadius)
                        {
                            // The cursor would be outside the follow circle, we need to move it
                            diff.Normalize(); // Obtain direction of diff
                            dist -= approxFollowCircleRadius;
                            lastCursorPosition += diff * dist;
                        }
                    });

                    var scoringTimes = lastSlider.Ticks.Select(t => t.StartTime).Concat(lastSlider.RepeatPoints.Select(r => r.StartTime)).OrderBy(t => t);
                    foreach (var time in scoringTimes)
                        computeVertex(time);
                    computeVertex(lastSlider.EndTime);

                    lastSlider.CursorPosition = lastCursorPosition;
                }
            }

            Distance = (BaseObject.StackedPosition - lastCursorPosition).Length * scalingFactor;
        }

        private void setTimingValues()
        {
            // Every timing inverval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure.
            DeltaTime = Math.Max(40, (t[0].StartTime - t[1].StartTime) / timeRate);
            TimeUntilHit = 450; // BaseObject.PreEmpt;
        }
    }
}