using System;
using System.Collections.Generic;

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using UnityEngine.EventSystems;

using Framework.Services;
using Framework.Support;

using ConditionalAttribute = System.Diagnostics.ConditionalAttribute;

namespace Framework.Dialogue {

  /// <summary>Manages UI widgets in a canvas used to display dialogue</summary>
  /// <remarks>
  ///   This class is intended to help implement the IDialogueCanvas interface based
  ///   and apply common standards to how UI elements need to be named to be
  ///   discoverable by the dialogue canvas.
  /// </remarks>
  [RequireComponent(typeof(Canvas))]
  public class DialogueCanvas : ScriptComponent, IDialogueCanvas {

    #region class ButtonEventProxy

    /// <summary>Forwards button events together with the assigned button index</summary>
    private class ButtonEventProxy : IDisposable {

      /// <summary>Creates a new button proxy and subscribes it to a button</summary>
      /// <param name="canvas">Canvas to which the button events will be delivered</param>
      /// <param name="button">Button this proxy will forward events for</param>
      /// <param name="buttonIndex">Index of option this button represents</param>
      /// <returns>A new button event proxy that has been subscribed to the button</returns>
      public static ButtonEventProxy CreateAndSubscribe(
        DialogueCanvas canvas, Button button, int buttonIndex
      ) {
        var proxy = new ButtonEventProxy(canvas, button, buttonIndex);
        button.onClick.AddListener(proxy.clickedDelegate);
        return proxy;
      }

      /// <summary>Initializes a new proxy for specified button with index</summary>
      /// <param name="canvas">Canvas to which button events will be sent</param>
      /// <param name="button">Button for which the proxy will forward events</param>
      /// <param name="buttonIndex">Button index that will be reported to the canvas</param>
      private ButtonEventProxy(DialogueCanvas canvas, Button button, int buttonIndex) {
        this.clickedDelegate = new UnityAction(clicked);

        this.canvas = canvas;
        this.buttonIndex = buttonIndex;
        this.button = button;
      }

      /// <summary>Unsubsribes from the buttons events</summary>
      public void Dispose() {
        if(this.button != null) {
          this.button.onClick.RemoveListener(this.clickedDelegate);
          this.button = null;
        }
        this.canvas = null;
      }

      /// <summary>Callback invoked when the user has clicked on the button</summary>
      private void clicked() {
        if(this.canvas != null) {
          this.canvas.Select(this.buttonIndex);
        }
      }

      /// <summary>Canvas to which button click events will be sent</summary>
      private DialogueCanvas canvas;
      /// <summary>Button to whose click event the proxy is subscribed</summary>
      private Button button;
      /// <summary>Button index the proxy will report to the canvas</summary>
      private int buttonIndex;
      /// <summary>Delete for the clicked() method</summary>
      private UnityAction clickedDelegate;

    }

    #endregion // class ButtonEventProxy

    /// <summary>Triggered when the user picks a choice or confirms the speech</summary>
    public event Action<int> Selected;

    /// <summary>Displays text spoken or thought by a character</summary>
    /// <param name="text">Text that will be displayed</param>
    public void ShowSpeech(string text) {
      ShowSpeechAndChoices(text, null);
    }

    /// <summary>Lets the player make a choice</summary>
    /// <param name="choices">Choices the player can select from</param>
    public void ShowChoices(string[] choices) {
      ShowSpeechAndChoices(null, choices);
    }

    /// <summary>
    ///   Displays text spoken or thought by a character (or the player) and lets
    ///   the player make a choice
    /// </summary>
    /// <param name="speech">Text that will be displayed</param>
    /// <param name="choices">Choices the player can select from</param>
    public void ShowSpeechAndChoices(string speech, string[] choices) {

      // Show or hide the speech panel as needed
      if(string.IsNullOrEmpty(speech)) {
        if(this.speechVisible) {
          TearDownSpeech();
          this.speechVisible = false;
        }
      } else {
        SetupNewSpeech(speech);
        this.speechVisible = true;
      }

      int choiceCount = ArrayHelper.CountNullableArray(choices);
      warnIfTooManyButtons(choiceCount);

      // Show or hide the choice buttons as needed
      if(choiceCount > 0) {
        SetupNewChoices(choices);
        this.selectableChoiceCount = choiceCount;
      } else if(this.selectableChoiceCount > 0) {
        TearDownChoices();
        this.selectableChoiceCount = 0;
      }

    }

    /// <summary>Hides the dialogue from the canvas</summary>
    public void Hide() {
      ShowSpeechAndChoices(null, null);
    }

    /// <summary>Picks a choice as if the user had clicked on a choice button</summary>
    /// <param name="choiceIndex">Index of the choice that has been selected</param>
    public void Select(int choiceIndex) {

      // If a choice was selected while the choice were not visible,
      // ignore this notification. Probably the user pressed a keyboard
      // shortcut when no choices were visible or double-selected a choice.
      if(choiceIndex >= this.selectableChoiceCount) {
        Debug.LogWarning(
          "Ignoring choice " + choiceIndex + " because no choice by that index " +
          "is currently being presented."
        );
        return;
      }

      // If there are choices being displayed, require one of them to be selected
      // (the user cannot continue to next speech panel if he's asked for a choice).
      if(this.selectableChoiceCount > 0) {
        if(choiceIndex == -1) {
          Debug.LogWarning(
            "Ignoring choice -1 (speech panel) because there are choices available"
          );
          return;
        }

        // Having picked a choice, kill the choice buttons
        TearDownChoices();
        this.selectableChoiceCount = 0;
      }

      // The user made a valid choice or confirmed the speech panel when
      // it was the only widget being shown.
      OnSelected(choiceIndex);

    }

    /// <summary>Called once before the first update cycle of the component</summary>
    protected override void Awake() {
      base.Awake();

      // This component needs to be attached to a canvas
      this.canvas = GetComponent<Canvas>();
      if(this.canvas == null) {
        Debug.LogError(
          "DialogueCanvas on game object '" + gameObject.name + "' does not have " +
          "a 'Canvas' component. Dialogue UI will not be displayed!"
        );
        return;
      }

      this.speechClickedDelegate = new UnityAction<BaseEventData>(speechClicked);

      // Look for the template controls we will use to display dialogue
      discoverSpeechPanel(this.canvas.gameObject);
      discoverButtonWidgets(this.canvas.gameObject);

      // Give derived classes a chance to do further intialization.
      // They can look for additional controls or remember original color values here
      InitializeWidgets(this.canvas, this.speechPanel, this.choiceButtons);

      // It is almost certain the UI was built the way it should look when all
      // controls are visible. Thus our first action should be to hide it.
      hideAllControlsInstantly();
    }

    /// <summary>Called once when the component and/or game object cease to exist</summary>
    protected virtual void Destroy() {
      unsubscribeFromButtonEvents();
    }

    /// <summary>Allows additional preparations to be made for the choice buttons</summary>
    /// <param name="canvas">Canvas that is hosting the controls</param>
    /// <param name="speechPanel">Speech panel used to show dialogue text</param>
    /// <param name="choiceButtons">Choice buttons ordered from top to bottom</param>
    protected virtual void InitializeWidgets(
      Canvas canvas, GameObject speechPanel, Button[] choiceButtons
    ) { }

    /// <summary>Called once before new speech is displayed</summary>
    /// <param name="speech">Speech that will be displayed</param>
    protected virtual void SetupNewSpeech(string speech) {
      SetSpeechPanelText(speech);
      ShowSpeechPanel();
    }

    /// <summary>Called once after the speech panel has faded out completely</summary>
    protected virtual void TearDownSpeech() {
      ShowSpeechPanel(false);
    }

    /// <summary>Called once before a new set of choices is displayed</summary>
    /// <param name="choices">Choices that will be displayed</param>
    protected virtual void SetupNewChoices(string[] choices) {
      int choiceCount = ArrayHelper.CountNullableArray(choices);
      for(int index = 0; index < choiceCount; ++index) {
        if(index < choiceCount) {
          SetButtonText(index, choices[index]);
          ShowButton(index);
        } else {
          ShowButton(index, false);
        }
      }
    }

    /// <summary>Called once after the choices have been faded out completely</summary>
    protected virtual void TearDownChoices() {
      if(this.choiceButtons != null) {
        int buttonCount = this.choiceButtons.Length;
        for(int index = 0; index < buttonCount; ++index) {
          ShowButton(index, false);
        }
      }
    }

    /// <summary>Fires the Selected event when the user has made a choice</summary>
    /// <param name="choiceIndex">Index of the choice the user has picked</param>
    /// <remarks>
    ///   If the current dialogue was only speech, the choice index is -1.
    /// </remarks>
    protected virtual void OnSelected(int choiceIndex) {
      //Debug.Log("Player picked dialogue choice " + choiceIndex);
      if(Selected != null) {
        Selected(choiceIndex);
      }
    }

    /// <summary>Shows or hides the speech panel</summary>
    /// <param name="show">Whether to show or hide the speech panel</param>
    protected void ShowSpeechPanel(bool show = true) {
      if(this.speechPanel != null) {
        this.speechPanel.gameObject.SetActive(show);
      }
    }

    /// <summary>Shows or hides the button with the specified index</summary>
    /// <param name="buttonIndex">Index of the button that will be enabled</param>
    /// <param name="show">Whether to show or hide the button</param>
    protected void ShowButton(int buttonIndex, bool show = true) {
      if(this.choiceButtons != null) {
        int buttonCount = this.choiceButtons.Length;
        if(buttonIndex < buttonCount) {
          Button button = this.choiceButtons[buttonIndex];
          if(button != null) {
            button.gameObject.SetActive(show);
          }
        }
      }
    }

    /// <summary>Changes the text in the speech panel</summary>
    /// <param name="text">Text that will be shown in the speech panel</param>
    protected void SetSpeechPanelText(string text) {
      if(this.speechText != null) {
        this.speechText.text = text;
      }
    }

    /// <summary>Changes the text on one of the buttons</summary>
    /// <param name="buttonIndex">Index of the button whose text will be changed</param>
    /// <param name="text">Text that will appear on the button</param>
    protected void SetButtonText(int buttonIndex, string text) {
      if(this.choiceTexts != null) {
        int buttonCount = this.choiceTexts.Length;
        if(buttonIndex < buttonCount) {
          Text textWidget = this.choiceTexts[buttonIndex];
          if(textWidget != null) {
            textWidget.text = text;
          }
        }
      }
    }

    /// <summary>Looks for the button template widgets in the canvas</summary>
    /// <param name="root">Game object under which the UI widget templates are</param>
    private void discoverSpeechPanel(GameObject root) {

      // Look for any panels that have "speech" in their name
      GameObject speechPanel = null;
      {
        Transform parent = root.transform;
        foreach(Transform child in parent) {
          if(child.name.Contains("Speech")) {
            speechPanel = child.gameObject;
          }
        }
      }

      // If no suitable panel was found, complain to the user so he knows
      // why the dialogue UI isn't working
      if(speechPanel == null) {
        Debug.LogWarning(
          "No speech panel found. " +
          "Dialogue canvas '" + gameObject.name + "' will be unable to display speech."
        );
      } else {
        this.speechPanel = speechPanel;

        // Look for a 'Text' widget in the speech panel to which we can assign
        // the dialogue text.
        this.speechText = this.speechPanel.GetComponentInChildren<Text>();
        if(speechText == null) {
          Debug.LogWarning(
            "No 'Text' widget found in the speech panel. " +
            "Dialogue canvas '" + gameObject.name + "' will be unable to display speech."
          );
        }
      }

    }

    /// <summary>Looks for the button template widgets in the canvas</summary>
    /// <param name="root">Game object under which the UI widget templates are</param>
    private void discoverButtonWidgets(GameObject root) {

      // Look up the buttons by which responses can be chosen
      var choiceButtons = new List<Button>();
      {
        Transform parent = root.transform;
        foreach(Transform child in parent) {
          if(child.name.Contains("Speech")) {
            speechPanel = child.gameObject;
          }
          if(child.name.Contains("Choice")) {
            Button buttonControl = child.GetComponent<Button>();
            if(buttonControl == null) {
              Debug.LogWarning(
                "Element '" + child.name + "' on dialogue canvas '" + gameObject.name + "' " +
                "is not a button and will not be used as a template."
              );
            } else {
              choiceButtons.Add(buttonControl);
            }
          }
        }
      }

      // If we found buttons, sort them and use them for the dialogue controls,
      // otherwise output a warning so the user knows why no buttons are appearing.
      int choiceButtonCount = choiceButtons.Count;
      if(choiceButtonCount == 0) {
        Debug.LogWarning(
          "No choice button templates found. " +
          "Dialogue canvas '" + gameObject.name + "' will be unable to use buttons."
        );
      } else {
        choiceButtons.Sort(compareByY);
        this.choiceButtons = choiceButtons.ToArray();
        subscribeToButtonEvents();

        // Locate the text elements for the choice buttons. Don't print a warning
        // if these are missing because making a game with textless buttons is possible.
        this.choiceTexts = new Text[choiceButtonCount];
        for(int index = 0; index < choiceButtonCount; ++index) {
          this.choiceTexts[index] = this.choiceButtons[index].GetComponentInChildren<Text>();
        }
      }

    }

    /// <summary>Subscribes a proxy to each button's click event</summary>
    private void subscribeToButtonEvents() {
      if(this.speechPanel != null) {
        EventTrigger trigger = this.speechPanel.GetComponent<EventTrigger>();
        if(trigger != null) {
          int triggerCount = trigger.triggers.Count;
          for(int index = 0; index < triggerCount; ++index) {
            if(trigger.triggers[index].eventID == EventTriggerType.PointerClick) {
              trigger.triggers[index].callback.AddListener(this.speechClickedDelegate);
            }
          }
        }
      }
      if(this.choiceButtons != null) {
        int buttonCount = this.choiceButtons.Length;
        this.buttonEventProxies = new ButtonEventProxy[buttonCount];
        for(int index = 0; index < buttonCount; ++index) {
          this.buttonEventProxies[index] = ButtonEventProxy.CreateAndSubscribe(
            this, this.choiceButtons[index].GetComponent<Button>(), index
          );
        }
      }
    }

    /// <summary>Unsubscribes from all button events</summary>
    private void unsubscribeFromButtonEvents() {
      if(this.speechPanel != null) {
        EventTrigger trigger = this.speechPanel.GetComponent<EventTrigger>();
        if(trigger != null) {
          int triggerCount = trigger.triggers.Count;
          for(int index = 0; index < triggerCount; ++index) {
            if(trigger.triggers[index].eventID == EventTriggerType.PointerClick) {
              trigger.triggers[index].callback.RemoveListener(this.speechClickedDelegate);
            }
          }
        }
      }
      if(this.buttonEventProxies != null) {
        int buttonCount = this.buttonEventProxies.Length;
        for(int index = buttonCount - 1; index >= 0; --index) {
          this.buttonEventProxies[index].Dispose();
        }
        this.buttonEventProxies = null;
      }
    }

    /// <summary>Hides all controls off without any animations</summary>
    /// <remarks>Only used when initially setting up the dialogue canvas</remarks>
    private void hideAllControlsInstantly() {
      ShowSpeechPanel(false);
      this.speechVisible = false;

      if(this.choiceButtons != null) {
        int buttonCount = this.choiceButtons.Length;
        for(int index = 0; index < buttonCount; ++index) {
          ShowButton(index, false);
        }
      }
      this.selectableChoiceCount = 0;
    }

    /// <summary>Called when the player clicks on the speech panel</summary>
    /// <param name="arguments">Not used</param>
    private void speechClicked(BaseEventData arguments) {
      Select(-1);
    }

    /// <summary>Warns the user if there are not enough button templates</summary>
    /// <param name="buttonCount">Number of buttons the current dialogue requires</param>
    [Conditional("DEBUG")]
    private void warnIfTooManyButtons(int buttonCount) {
      int maximumButtonCount = this.choiceButtons.Length;
      if(buttonCount > maximumButtonCount) {
        Debug.LogWarning(
          "Requested " + buttonCount.ToString() + " buttons on DialogueCanvas '" +
          gameObject.name + "', but only templates for " + maximumButtonCount.ToString() +
          " present. Create more templates or use less buttons."
        );
      }
    }

    /// <summary>Compares two transforms by their local Y coordinate</summary>
    /// <param name="first">First transform that will be compared</param>
    /// <param name="second">Second transform that will be compared</param>
    /// <returns>The relationship of the Y coordinates of both transforms</returns>
    private static int compareByY(Button first, Button second) {
      return Math.Sign(second.transform.localPosition.y - first.transform.localPosition.y);
    }

    // Stuff used to suppress redundant setups/teardowns

    /// <summary>Whether the speech panel is being displayed</summary>
    private bool speechVisible;
    /// <summary>Number of choice buttons that are being displayed</summary>
    private int selectableChoiceCount;

    // Stuff used to provide quick access to properties from derived classes

    /// <summary>Canvas in which the dialogue UI will be displayed</summary>
    private Canvas canvas;
    /// <summary>Game object hosting the UI panel in which speech will be displayed</summary>
    private GameObject speechPanel;
    /// <summary>Text that is being displayed in the speech panel</summary>
    private Text speechText;
    /// <summary>Button controls the player can click to make choices</summary>
    private Button[] choiceButtons;
    /// <summary>Text that is shown on each of the chocie buttons</summary>
    private Text[] choiceTexts;
    /// <summary>Delegate for the speechClicked() method</summary>
    private UnityAction<BaseEventData> speechClickedDelegate;
    /// <summary>Proxies that forward button click events to the dialogue canvas</summary>
    private ButtonEventProxy[] buttonEventProxies;

  }

} // namespace Framework.Dialogue