#if HAVE_NODECANVAS

using System;

using UnityEngine;

using ParadoxNotion.Design;
using NodeCanvas.Framework;

using Framework.Cameras;
using Framework.Services;

namespace Framework.Dialogue {

  /// <summary>Displays dialogue to the user</summary>
  [Category("Dialogue")]
  [Icon("Dialogue")]
  [Description("Display speech to the player in a dialogue UI")]
  public class DisplayDialogueTask : ActionTask {

    /// <summary>On whom the dialogue UI will be opened</summary>
    [RequiredField]
    public BBParameter<DialogueOwner> DialogueOwner;

    /// <summary>Text that will be displayed as speech in the dialogue UI</summary>
    [Multiline, TextAreaField(50)]
    public string Text;

    /// <summary>Choices the user can make</summary>
    public string[] Choices;

    /// <summary>
    ///   Called when the instance is first activated to provide it with any
    ///   external services it relies on.
    /// </summary>
    /// <param name="cameraManager">Camera manager that provides the active camera</param>
    /// <param name="dialogueManager">
    ///   Dialogue manager through which the dialogue UI will be displayed
    /// </param>
    protected virtual void Inject(
      ICameraManager cameraManager, IDialogueManager dialogueManager
    ) {
      this.cameraManager = cameraManager;
      this.dialogueManager = dialogueManager;
    }

    /// <summary>Provides a summary description of what this action does</summary>
    protected override string info {
      get {
        int choiceCount = countChoices();

        string text = "\"" + this.Text + "\"";
        if(choiceCount > 0) {
          text += "\n";
        }
        for(int index = 0; index < choiceCount; ++index) {
          text += "\n[" + this.Choices[index] + "]";
        }
        return text;
      }
    }

    /// <summary>Called only once before the action is executed for the first time</summary>
    /// <returns>Null if everything worked out, an error message in case of an error</returns>
    protected override string OnInit() {
      this.dialogueChoiceSelectedDelegate = new Action<int>(dialogueChoiceSelected);
      storeChoiceIndexOnBlackboard(-1);

      return base.OnInit();
    }

    /// <summary>Called once when the action is executed</summary>
    protected override void OnExecute() {
      ServiceInjector.InjectDependencies(this);

      // We have to expect that this state leaves via choice condition tasks, so clear
      // the previously made dialogue choice to prevent the conditions from triggering
      // until the user has selected a choice for *this* dialogue.
      removeChoiceIndexOnBlackboard();

      // Fetch for the currently active camera to search for a placement the dialogue
      UnityEngine.Camera activeCamera = getActiveCamera();
      if(activeCamera == null) {
        Debug.LogError("Could not determine active camera");
        return;
      }

      // Let tThe dialogue manager score the available placements and look for
      // the one that is best visible to the player.
      DialoguePlacement placement = this.dialogueManager.FindPlacementOnActor(
        activeCamera.transform, this.DialogueOwner.value.gameObject
      );
      #if false
      if(placement == null) {
        Debug.LogWarning(
          "Could not find a suitable dialogue UI placement on '" + this.DialogueOwner.name + "' " +
          "(GameObject = '" + this.DialogueOwner.value.name + "'), " +
          "good luck, player, you're stuck!"
        );

        // Coup de grace. Bail out of the task even though the dialogue wasn't shown.
        EndAction();
        return;
      }
      #endif

      // Show the dialogue and subscribe to the
      this.canvas = this.dialogueManager.ShowDialogue(placement);
      this.canvas.ShowSpeechAndChoices(this.Text, this.Choices);
      this.canvas.Selected += this.dialogueChoiceSelectedDelegate;
    }

    /// <summary>Called when the action ends due to any reason</summary>
    protected override void OnStop() {
      if(this.canvas != null) {
        this.canvas.Selected -= this.dialogueChoiceSelectedDelegate;
        this.canvas = null;
        // Do not hide the canvas, more dialogue may be following
      }
    }

    /// <summary>Called when the player selects a choice in the dialogue</summary>
    /// <param name="choiceIndex">Index of the choice the player has selected</param>
    private void dialogueChoiceSelected(int choiceIndex) {
      storeChoiceIndexOnBlackboard(choiceIndex);

      EndAction();
    }

    /// <summary>Removes the index of the selected dialogue choice from the blackboard</summary>
    private void removeChoiceIndexOnBlackboard() {
      const string ChoiceIndexVariableName = "DialogueChoiceIndex";

      IBlackboard choiceBlackboard = ownerBlackboard;
      if(choiceBlackboard == null) {
        Debug.LogError(
          "DialogueChoiceCondition could not find a blackboard in its state machine. " +
          "A blackboard is required to store the choices made by the player. " +
          "Conditions on multiple choice dialogue will not work."
        );
        return;
      }

      // If it's null, we'll already have complaine in OnInit()!
      Variable choiceIndexVariable = choiceBlackboard.GetVariable(
        ChoiceIndexVariableName, typeof(int)
      );
      if(choiceIndexVariable != null) {
        choiceBlackboard.RemoveVariable(ChoiceIndexVariableName);
      }
    }

    /// <summary>Stores the index of the selected dialogue choice on the blackboard</summary>
    /// <param name="choiceIndex">Index that will be stored on the blackboard</param>
    private void storeChoiceIndexOnBlackboard(int choiceIndex) {
      const string ChoiceIndexVariableName = "DialogueChoiceIndex";

      IBlackboard choiceBlackboard = ownerBlackboard;
      if(choiceBlackboard == null) {
        Debug.LogError(
          "DisplayDialogueAction could not find a blackboard in its state machine. " +
          "A blackboard is required to store the choices made by the player. " +
          "Conditions on multiple choice dialogue will not work."
        );
        return;
      }

      // If it's null, we'll already have complaine in OnInit()!
      Variable choiceIndexVariable = choiceBlackboard.GetVariable(
        ChoiceIndexVariableName, typeof(int)
      );
      if(choiceIndexVariable == null) {
        choiceIndexVariable = choiceBlackboard.AddVariable(ChoiceIndexVariableName, typeof(int));
      }

      choiceIndexVariable.value = choiceIndex;
    }

    /// <summary>Looks for the currently active camera</summary>
    /// <returns>The currently active camera or null if it couldn't be determined</returns>
    private Camera getActiveCamera() {
      Camera activeCamera;
      {
        if(this.cameraManager != null) {
          activeCamera = this.cameraManager.ActiveCamera;
        } else {
          activeCamera = null;
        }
        if(activeCamera == null) {
          activeCamera = UnityEngine.Camera.current;
        }
        if(activeCamera == null) {
          activeCamera = UnityEngine.Camera.main;
        }
      }

      return activeCamera;
    }

    /// <summary>Counts the number of choices the user can choose from</summary>
    /// <returns>The number of choices available to the user</returns>
    private int countChoices() {
      if(this.Choices == null) {
        return 0;
      } else {
        return this.Choices.Length;
      }
    }

    /// <summary>Camera manager through which the scene is being viewed</summary>
    [NonSerialized]
    private ICameraManager cameraManager;

    /// <summary>Manages the currently active dialogue UI in the game</summary>
    [NonSerialized]
    private IDialogueManager dialogueManager;

    /// <summary>Currently active dialogue canvas</summary>
    [NonSerialized]
    private IDialogueCanvas canvas;

    /// <summary>Called when the player selcects a dialogue choice</summary>
    [NonSerialized]
    private Action<int> dialogueChoiceSelectedDelegate;

  }

} // namespace Framework.Dialogue

#endif // HAVE_NODECANVAS