using System;
using System.Collections.Generic;

using UnityEngine;

#if UNITTEST

using NUnit.Framework;

namespace Framework.Navigation.Platformer {

  /// <summary>Unit tests for the navigator class</summary>
  [TestFixture]
  internal class NavigatorTest {

    /// <summary>Called before each test is run</summary>
    [SetUp]
    public void Setup() {
      createPlatforms();
      linkPlatforms();
      setupConstraints();
      createTargets();
    }

    /// <summary>Verifies that the path finding code can navigate the test level</summary>
    [Test]
    public void CanFindPath() {
      IAsyncResult asyncResult = Navigator.BeginFindPath(
        this.agent, this.goal, this.constraints
      );
      IList<Instruction> instructions = Navigator.EndFindPath(asyncResult);

      Assert.IsNotNull(instructions);
    }

    /// <summary>Creates the platforms on which the agent can stand</summary>
    private void createPlatforms() {
      this.from = new Ground() {
        Heights = new Vector2[] {
          new Vector2(0, 0),
          new Vector2(10, 0)
        }
      };

      this.other = new Ground[4];
      this.other[0] = new Ground() {
        Heights = new Vector2[] {
          new Vector2(5, 10),
          new Vector2(15, 10)
        }
      };
      this.other[1] = new Ground() {
        Heights = new Vector2[] {
          new Vector2(-15, 10),
          new Vector2(-5, 10)
        }
      };
      this.other[2] = new Ground() {
        Heights = new Vector2[] {
          new Vector2(-5, 20),
          new Vector2(5, 20)
        }
      };
      this.other[3] = new Ground() {
        Heights = new Vector2[] {
          new Vector2(5, 30),
          new Vector2(15, 30)
        }
      };

      this.to = new Ground() {
        Heights = new Vector2[] {
          new Vector2(10, 40),
          new Vector2(20, 40)
        }
      };
    }

    /// <summary>Links the platforms together via jump targets</summary>
    private void linkPlatforms() {
      this.from.JumpTargets = new Ground[] { this.other[0], this.other[1] };
      this.other[0].JumpTargets = new Ground[] { this.from, this.other[1], this.other[2] };
      this.other[1].JumpTargets = new Ground[] { this.from, this.other[0], this.other[2] };
      this.other[2].JumpTargets = new Ground[] { this.other[0], this.other[1], this.other[3] };
      this.other[3].JumpTargets = new Ground[] { this.to, this.other[2] };
      this.to.JumpTargets = new Ground[] { this.other[3] };
    }

    /// <summary>Sets up the agent's movement constraints</summary>
    private void setupConstraints() {
      this.constraints = new Constraints() {
        MaximumJumpHeight = 12.5f,
        MaximumDropHeight = 20.0f,
        MaximumJumpDistance = 12.5f
      };
    }

    /// <summary>Creates the targets between which path finding takes place</summary>
    private void createTargets() {
      this.agent = new Locator();
      this.agent.CurrentGround = this.from;

      this.goal = new Locator();
      this.goal.CurrentGround = this.to;
    }

    /// <summary>Ground the agent is starting at</summary>
    private Ground from;
    /// <summary>Ground the agent wants to reach</summary>
    private Ground to;
    /// <summary>Other ground nodes between 'from' and 'to'</summary>
    private Ground[] other;
    /// <summary>Constraints by which the agent's movement is limited</summary>
    private Constraints constraints;
    /// <summary>Agent that needs a path to the goal</summary>
    private Locator agent;
    /// <summary>Goal the agent wants to reach</summary>
    private Locator goal;

  }

} // namespace Framework.Navigation.Platformer

#endif // UNITTEST