using System;

using UnityEngine;

using Framework.Services;

namespace Framework.Dialogue {

  /// <summary>Manages the dialogue UI elements in the world</summary>
  [ServiceScope(Scope.Session)]
  public class DialogueManager : ScriptComponent, IDialogueManager {

    /// <summary>Maximum distance from which a dialogue UI can be triggered</summary>
    public const float DefaultMaximumDistance = 2.5f;

    /// <summary>Prefab that will be instantiated when a dialogue canvas is needed</summary>
    public DialogueCanvas Prefab;

    /// <summary>Finds the best dialogue canvas placement on an owner</summary>
    /// <param name="viewer">Viewer for which a placement will be searched</param>
    /// <param name="actor">Actor the placement has to be attached to</param>
    /// <returns>The best dialogue canvas placement for the specified owner</returns>
    public DialoguePlacement FindPlacementOnActor(
      Transform viewer, GameObject actor
    ) {
      return FindPlacementOnActor(viewer, actor, DefaultMaximumDistance);
    }

    /// <summary>Finds the best dialogue canvas placement on an owner</summary>
    /// <param name="viewer">Viewer for which a placement will be searched</param>
    /// <param name="actor">Actor the placement has to be attached to</param>
    /// <param name="maximumDistance">
    ///   Maximum distance the placement may have from the viewer
    /// </param>
    /// <returns>The best dialogue canvas placement for the specified owner</returns>
    public DialoguePlacement FindPlacementOnActor(
      Transform viewer, GameObject actor, float maximumDistance
    ) {
      DialogueOwner owner = actor.GetComponentInChildren<DialogueOwner>();
      if(owner != null) {
        Transform placement = owner.GetBestPlacement(viewer, maximumDistance);
        if(placement == null) {
          Debug.LogWarning(
            "No suitable dialogue placement found on owner '" + actor.name + "', " +
            "falling back to default placement."
          );
        } else {
          return new DialoguePlacement(actor, owner, placement);
        }
      }

      return new DialoguePlacement(
        actor, owner, getOrCreateFallbackPlacement(viewer, owner.transform)
      );
    }

    /// <summary>Finds the best dialogue canvas placement not attached to an owner</summary>
    /// <param name="viewer">Position of the viewer in the world</param>
    /// <returns>The best dialogue canvas placement not attached to any owner</returns>
    public DialoguePlacement FindPlacementInWorld(Transform viewer) {
      throw new NotImplementedException("Not implemented yet");
    }

    /// <summary>Displays a new dialogue canvas at a specific location</summary>
    /// <param name="placement">Where the dialogue canvas will be displayed</param>
    public IDialogueCanvas ShowDialogue(DialoguePlacement placement) {

      // See if we already have a canvas open for this actor and if so, just move it
      if(this.currentDialogueCanvas != null) {
        if(ReferenceEquals(this.currentActor, placement.Actor)) {
          // TODO: Animate canvas towards new placement
          //this.currentDialogueCanvas.transform.position = placement.Transform.position;
          //this.currentDialogueCanvas.transform.rotation = placement.Transform.rotation;
          this.currentDialogueCanvas.transform.SetParent(placement.Transform);
          return this.currentDialogueCanvas;
        } else {
          this.currentDialogueCanvas.Hide();
          // TODO: Destroy canvas after hiding
          //   Requires an event notifying us when the canvas finished its hiding anim
        }
      }

      IDialogueCanvas canvas = placement.Owner.GetOrCreateDialogueCanvas(placement.Transform);

      // TODO: Get rid of ugly downcast
      //   If the canvas can move to a new location (see IDialogueCanvas2),
      //   we don't need to deal with transforms by hand and have a clean interface
      this.currentDialogueCanvas = canvas as DialogueCanvas;

      return canvas;
    }

    /// <summary>Moves the currently active dialoge to a new location</summary>
    /// <param name="newTransform">New location the dialoge should be moved to</param>
    public void MoveDialogue(Transform newTransform) {
      if(this.currentDialogueCanvas != null) {
        // TODO: Animate canvas towards new placement
        this.currentDialogueCanvas.transform.position = newTransform.position;
        this.currentDialogueCanvas.transform.rotation = newTransform.rotation;
      }
    }

    /// <summary>Kills the currently active dialogue</summary>
    public void HideDialogue() {
      if(this.currentDialogueCanvas != null) {
        this.currentDialogueCanvas.Hide();
        // TODO: Destroy canvas after hiding
        this.currentDialogueCanvas = null;
        this.currentActor = null;
      }
    }

    /// <summary>Currently active dialogue UI</summary>
    public IDialogueCanvas ActiveDialogueCanvas {
      get { return this.currentDialogueCanvas; }
    }

    /// <summary>Creates a fallback placement for the specified game object</summary>
    /// <param name="viewer">Position of the viewer in the scene</param>
    /// <param name="owner">Position of the dialogue owner</param>
    /// <returns>A transform that serves as a fallback placement for dialogue UI</returns>
    private static Transform getOrCreateFallbackPlacement(Transform viewer, Transform owner) {
      const string FallbackObjectName = "FallbackDialoguePlacement";

      Transform placement = owner.transform.Find(FallbackObjectName);
      if(placement == null) {
        var placementGameObject = new GameObject(FallbackObjectName);
        placement = placementGameObject.transform;
        placement.SetParent(owner);
      }

      // TODO: Position placement between viewer and owner

      return placement;
    }

    /// <summary>Transform to which the canvas has been attached</summary>
    private Transform currentCanvasRoot;
    /// <summary>Currently active dialogue canvas, if any</summary>
    private DialogueCanvas currentDialogueCanvas;
    /// <summary>Actor the active dialogue canvas is being shown for</summary>
    private GameObject currentActor; // null for world

  }

} // namespace Framework.Dialogue