using System;
using System.Collections.Generic;

using UnityEngine;

using Framework.Selection;
using Framework.Services;
using Framework.Support;

namespace Framework.UI {

  /// <summary>Highlights the selection of an actor</summary>
  public class SelectionHighlighter : ScriptComponent {
    
    /// <summary>
    ///   Selection tracker for which the highlighting system will highlight items
    /// </summary>
    public SelectionTracker SelectionTracker;

    /// <summary>Color in which highlighted objects will be shown</summary>
    public Color HighlightColor = Color.red;

    /// <summary>Color in which selected objects will be shown</summary>
    public Color SelectionColor = Color.white;

    /// <summary>Called once per visual frame</summary>
    protected virtual void Update() {
      if (this.SelectionTracker != this.usedSelectionTracker) {
        if (this.highlightedItems == null) {
          createDelegatesAndCollections();
        }
        
        if (this.usedSelectionTracker != null) {
          detachFromAllEvents();
        }
        this.usedSelectionTracker = this.SelectionTracker;
      }

      if (this.usedSelectionTracker != null) {
        resyncEventSubscriptions();
      }
    }

    /// <summary>Attaches and detaches from change notifications as needed</summary>
    private void resyncEventSubscriptions() {
      if (this.usedSelectionTracker.CanHighlight != this.highlightEventsAttached) {
        if (this.usedSelectionTracker.CanHighlight) {
          attachToHighlightEvents();
        } else {
          detachFromHighlightEvents();
        }
      }

      if (this.usedSelectionTracker.CanSelect != this.selectionEventsAttached) {
        if (this.usedSelectionTracker.CanSelect) {
          attachToSelectionEvents();
        } else {
          detachFromSelectionEvents();
        }
      }
    }

    /// <summary>Detaches from all events of the selection tracker</summary>
    private void detachFromAllEvents() {
      if (this.highlightEventsAttached) {
        detachFromHighlightEvents();
      }
      if (this.selectionEventsAttached) {
        detachFromSelectionEvents();
      }
    }
    
    /// <summary>Called when the highlighter component gets enabled</summary>
    protected virtual void OnEnable() {
      if (this.usedSelectionTracker != null) {
        resyncEventSubscriptions();
      }
    }

    /// <summary>Called when the highlighter component gets disabled</summary>
    protected virtual void OnDisable() {
      if (this.usedSelectionTracker != null) {
        detachFromAllEvents();
      }
    }

    /// <summary>Called when the component gets removed from a game object</summary>
    protected virtual void OnDestroy() {
      
      // If selection tracker has been destroyed, its overloaded equals operator
      // will compare as equal to null. In this case, wo only need to clear out
      // any objects still marked as selected or highlighted
      if (this.usedSelectionTracker == null) {
        selectedItemsClearing();
        highlightedItemsClearing();
      } else {
        detachFromAllEvents();
      }

    }

    /// <summary>Subscribes to the notifications for the highlighted object collection</summary>
    private void attachToHighlightEvents() {
      var observableHighlightedSet = (
        (IObservableCollection<Selectable>) this.usedSelectionTracker.HighlightedObjects
      );

      observableHighlightedSet.Clearing += this.highlightedItemsClearingDelegate;
      observableHighlightedSet.ItemAdded += this.highlightedItemAddedDelegate;
      observableHighlightedSet.ItemRemoved += this.highlightedItemRemovedDelegate;

      // If any objects are already in the highlight collection make them highlighted 
      foreach (Selectable selectable in this.usedSelectionTracker.HighlightedObjects) {
        highlightedItemAdded(selectable);
      }

      this.highlightEventsAttached = true;
    }
    
    /// <summary>Subscribes to the notifications for the selected object collection</summary>
    private void attachToSelectionEvents() {
      var observableSelectedSet = (
        (IObservableCollection<Selectable>)this.usedSelectionTracker.SelectedObjects
      );

      observableSelectedSet.Clearing += this.selectedItemsClearingDelegate;
      observableSelectedSet.ItemAdded += this.selectedItemAddedDelegate;
      observableSelectedSet.ItemRemoved += this.selectedItemRemovedDelegate;

      // If any bjects are alreadz in the selected collection make them highlighted
      foreach(Selectable selectable in this.usedSelectionTracker.SelectedObjects) {
        selectedItemAdded(selectable);
      }
      
      this.selectionEventsAttached = true;
    }

    /// <summary>Unsubscribes from the notifications of the highlighted object collection</summary>
    private void detachFromHighlightEvents() {
      var observableHighlightedSet = (
        (IObservableCollection<Selectable>)this.usedSelectionTracker.HighlightedObjects
      );

      this.highlightedItemsClearing();

      observableHighlightedSet.ItemRemoved -= this.highlightedItemRemovedDelegate;
      observableHighlightedSet.ItemAdded -= this.highlightedItemAddedDelegate;
      observableHighlightedSet.Clearing -= this.highlightedItemsClearingDelegate;

      this.highlightEventsAttached = false;
    }

    /// <summary>Unsubscribes from the notifications of the selected object collection</summary>
    private void detachFromSelectionEvents() {
      var observableSelectedSet = (
        (IObservableCollection<Selectable>)this.usedSelectionTracker.SelectedObjects
      );

      this.selectedItemsClearing();

      observableSelectedSet.ItemRemoved -= this.selectedItemRemovedDelegate;
      observableSelectedSet.ItemAdded -= this.selectedItemAddedDelegate;
      observableSelectedSet.Clearing -= this.selectedItemsClearingDelegate;

      this.selectionEventsAttached = true;
    }
    
    /// <summary>Creates the permanent collections and delegates used by the instance</summary>
    private void createDelegatesAndCollections() {
      this.highlightedItems = new List<Selectable>();
      this.selectedItems = new List<Selectable>();
      
      this.highlightedItemsClearingDelegate = new Action(highlightedItemsClearing);
      this.highlightedItemAddedDelegate = new Action<Selectable>(highlightedItemAdded);
      this.highlightedItemRemovedDelegate = new Action<Selectable>(highlightedItemRemoved);
      
      this.selectedItemsClearingDelegate = new Action(selectedItemsClearing);
      this.selectedItemAddedDelegate = new Action<Selectable>(selectedItemAdded);
      this.selectedItemRemovedDelegate = new Action<Selectable>(selectedItemRemoved);

      this.selectionEventsAttached = false;
    }

    /// <summary>Called when the highlighted items set is being cleared</summary>
    private void highlightedItemsClearing() {
      foreach(Selectable selectable in this.usedSelectionTracker.HighlightedObjects) {
        highlightedItemRemoved(selectable);
      }
    }

    /// <summary>Called when a new item is added to the highlighted items set</summary>
    /// <param name="item">Item that has been added to the highlighted items set</param>
    private void highlightedItemAdded(Selectable item) {
      this.highlightedItems.Add(item);

#if HAVE_HIGHLIGHTING_SYSTEM
      HighlightingSystem.Highlighter highlighter;
      {
        highlighter = item.GetComponent<HighlightingSystem.Highlighter>();
        if(highlighter == null) {
          highlighter = item.gameObject.AddComponent<HighlightingSystem.Highlighter>();
        }
      }
      
      highlighter.ConstantOnImmediate(this.HighlightColor);
#endif // HAVE_HIGHLIGHTING_SYSTEM
    }

    /// <summary>Called when a new item is removed from the highlighted items set</summary>
    /// <param name="item">Item that has been removed from the highlighted items set</param>
    private void highlightedItemRemoved(Selectable item) {
      this.highlightedItems.Remove(item);

      // The component or its game object may have already been destroyed without
      // unregistering. In this case, the equals operators reports equality with null.
      if(item == null) {
        return;
      }
      
#if HAVE_HIGHLIGHTING_SYSTEM
      HighlightingSystem.Highlighter highlighter;
      {
        highlighter = item.GetComponent<HighlightingSystem.Highlighter>();
        if(highlighter != null) {
          highlighter.ConstantOffImmediate();
          if(this.selectedItems.Contains(item)) {
            highlighter.ConstantOnImmediate(this.SelectionColor);
          }
        }
      }
#endif // HAVE_HIGHLIGHTING_SYSTEM
    }

    /// <summary>Called when the selected items set is being cleared</summary>
    private void selectedItemsClearing() {
      foreach(Selectable selectable in this.usedSelectionTracker.SelectedObjects) {
        selectedItemRemoved(selectable);
      }
    }

    /// <summary>Called when a new item is added to the selected items set</summary>
    /// <param name="item">Item that has been added to the selected items set</param>
    private void selectedItemAdded(Selectable item) {
      this.selectedItems.Add(item);
      
#if HAVE_HIGHLIGHTING_SYSTEM
      HighlightingSystem.Highlighter highlighter;
      {
        highlighter = item.GetComponent<HighlightingSystem.Highlighter>();
        if(highlighter == null) {
          highlighter = item.gameObject.AddComponent<HighlightingSystem.Highlighter>();
        }
      }
      
      // Highlight overrides selection
      if(!this.highlightedItems.Contains(item)) {
        highlighter.ConstantOnImmediate(this.SelectionColor);
      }
#endif // HAVE_HIGHLIGHTING_SYSTEM
    }

    /// <summary>Called when a new item is removed from the selected items set</summary>
    /// <param name="item">Item that has been removed from the selected items set</param>
    private void selectedItemRemoved(Selectable item) {
      this.selectedItems.Remove(item);

      // The component or its game object may have already been destroyed without
      // unregistering. In this case, the equals operators reports equality with null.
      if(item == null) {
        return;
      }
      
#if HAVE_HIGHLIGHTING_SYSTEM
      HighlightingSystem.Highlighter highlighter;
      {
        highlighter = item.GetComponent<HighlightingSystem.Highlighter>();
        if(highlighter != null) {
          if(!this.highlightedItems.Contains(item)) {
            highlighter.ConstantOffImmediate();
          }
        }
      }
#endif // HAVE_HIGHLIGHTING_SYSTEM
    }
    
    /// <summary>Copy of the publicly assigned selection tracker</summary>
    /// <remarks>>
    ///   Theoretically, someone could assign a different selection tracker to this
    ///   component. Then we have to remove highlighters from all selected objects
    ///   in the old selection tracker and add highlighters to all selected objects
    ///   in the new tracker. This field helps us know when we need these measures.
    /// </remarks>
    private SelectionTracker usedSelectionTracker;

    /// <summary>Whether the highlighter is currently attached to the tracker</summary>
    private bool isAttached;
    
    /// <summary>Game objects that are currently being displayed as highlighted</summary>
    private IList<Selectable> highlightedItems;
    /// <summary>Game objects that are currently being displayed as selected</summary>
    private IList<Selectable> selectedItems;

    /// <summary>Whether the higlighting callbacks are current subscribed</summary>
    private bool highlightEventsAttached;
    /// <summary>Delegate for the <see cref="highlightedItemsClearing" /> method</summary>
    private Action highlightedItemsClearingDelegate;
    /// <summary>Delegate for the <see cref="highlightedItemAdded" /> method</summary>
    private Action<Selectable> highlightedItemAddedDelegate;
    /// <summary>Delegate for the <see cref="highlightedItemRemoved" /> method</summary>
    private Action<Selectable> highlightedItemRemovedDelegate;

    /// <summary>Whether the selection callbacks are current subscribed</summary>
    private bool selectionEventsAttached;
    /// <summary>Delegate for the <see cref="selectedItemsClearing" /> method</summary>
    private Action selectedItemsClearingDelegate;
    /// <summary>Delegate for the <see cref="selectedItemAdded" /> method</summary>
    private Action<Selectable> selectedItemAddedDelegate;
    /// <summary>Delegate for the <see cref="selectedItemRemoved" /> method</summary>
    private Action<Selectable> selectedItemRemovedDelegate;

  }

} // namespace Framework.UI