using System;
using System.Collections.Generic;

using UnityEngine;
using UnityEngine.UI;

namespace Framework.Dialogue2 {

  /// <summary>Interface for accessing the widgets of a dialogue canvas instance</summary>
  public class UGuiDialogueWidgets : IDisposable {

    /// <summary>Initializes a new UGui dialogue widget manager</summary>
    /// <param name="uGuiCanvas">UGui canvas on which the dialogue widgets are placed</param>
    public UGuiDialogueWidgets(Canvas uGuiCanvas) {
      this.uGuiCanvas = uGuiCanvas;
    }

    /// <summary>Called after the widget controller has been constructed</summary>
    public virtual void Initialize() {
      this.speechWidget = DiscoverSpeechPanel();
      this.choiceWidgets = DiscoverChoiceButtons();
    }

    /// <summary>Destroys the canvas</summary>
    public void Dispose() {
      if(this.uGuiCanvas != null) {
        this.speechWidget = null;
        this.choiceWidgets.Clear();

        GameObject.Destroy(this.uGuiCanvas);
        this.uGuiCanvas = null;
      }
    }

    /// <summary>The maximum number of choice buttons the dialogue canvas can display</summary>
    /// <remarks>
    ///   Also see the remarks section of the <see cref="DiscoverChoiceButtons" /> method,
    ///   if the widget controller implementation creates buttons dynamically, just return
    ///   some ridiculously high number (i.e. int.MaxValue), otherwise, return the number
    ///   of buttons that have been set up on the canvas
    /// </remarks>
    public virtual int MaximumChoiceCount { get { return this.choiceWidgets.Count; } }

    /// <summary>Looks for the speech panel in the widget controller's canvas</summary>
    /// <remarks>
    ///   This simply goes by the convention that the speech panel game object will have
    ///   the text 'Speech' in its name.
    /// </remarks>
    protected virtual Transform DiscoverSpeechPanel() {
      Transform speechPanel = null;
      {
        Transform parent = this.uGuiCanvas.transform;
        foreach(Transform child in parent) {
          if(child.name.Contains("Speech")) {
            Text textControl = child.GetComponentInChildren<Text>();
            if(textControl == null) {
              Debug.LogWarning(
                "Element '" + child.name + "' on dialogue canvas " +
                "'" + this.uGuiCanvas.name + "' is not a text control " +
                "and will not be used as a template."
              );
            } else {
              speechPanel = child;
            }
          }
        }
      }

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

      return speechPanel;
    }

    /// <summary>Looks for the choice buttons in the widget controller's canvas</summary>
    /// <remarks>
    ///   <para>
    ///     This simply goes by the convention that the choice button game objects will
    ///     have the text 'Choice' in their names.
    ///   </para>
    ///   <para>
    ///     There are two ways choice buttons can be set up: the first way is to place
    ///     the maximum number of choice buttons you will possibly use on your UGUI canvas
    ///     straight away and hide the ones not used at runtime when dialogue is shown.
    ///   </para>
    ///   <para>
    ///     The other option is to create exactly one choice button and when dialogue is
    ///     shown, duplicate it to obtain the required number of choice buttons. This is
    ///     more complex as it requires the widget controller to figure out where to
    ///     place the additional buttons (i.e. do they stack vertically in some scroll box
    ///     or are there two colums of them, etc.)
    ///   </para>
    ///   <para>
    ///     The default widget controller implementation is therefore assuming option 1
    ///     (all buttons pre-created) is used.
    ///   </para>
    /// </remarks>
    protected virtual IList<Transform> DiscoverChoiceButtons() {
      var choiceButtons = new List<Transform>();
      {
        Transform parent = this.uGuiCanvas.transform;
        foreach(Transform child in parent) {
          if(child.name.Contains("Choice") && !child.name.Contains("Speech")) {
            Button buttonControl = child.GetComponentInChildren<Button>();
            if(buttonControl == null) {
              Debug.LogWarning(
                "Element '" + child.name + "' on dialogue canvas " +
                "'" + this.uGuiCanvas.name + "' does not contain a button " +
                "and will not be used as a template."
              );
            } else {
              choiceButtons.Add(child);
            }
          }
        }
      }

      // If we found buttons, use them for the dialogue controls, otherwise complain
      // to the user so he knows why no choices are appearing.
      int choiceButtonCount = choiceButtons.Count;
      if(choiceButtonCount == 0) {
        Debug.LogError(
          "No choice button templates found. " +
          "Dialogue canvas '" + this.uGuiCanvas.name + "' will be unable to use buttons."
        );
      }

      return choiceButtons;
    }

    /// <summary>Canvas on which the controller's widgets are placed</summary>
    protected Canvas Canvas { get { return this.uGuiCanvas; } }

    /// <summary>Widget in which speech will be displayed</summary>
    protected Transform SpeechWidget { get { return speechWidget; } }

    /// <summary>Widgets in which choices available to the player will be displayed</summary>
    protected IList<Transform> ChoiceWidgets { get { return this.choiceWidgets; } }

    /// <summary>UGui canvas on which the controls are placed</summary>
    private Canvas uGuiCanvas;
    /// <summary>Transform of the widget containing the speech panel</summary>
    private Transform speechWidget;
    /// <summary>Transofrms of the widgets containing the button controls</summary>
    private IList<Transform> choiceWidgets;

  }

} // namespace Framework.Dialogue