#if HAVE_USEQUENCER

using System;

using UnityEngine;

using WellFired;
using WellFired.Shared;

namespace Framework.Camera {

  /// <summary>Displays a camera targeting event in the uSequencer timeline</summary>
  [CustomUSEditor(typeof(USFadeCameraEvent))]
  public class USFadeCameraEventEditor : USEventBaseEditor {

    /// <summary>Renders the event in the uSequencer timeline</summary>
    /// <param name="myArea">Area covered by the event</param>
    /// <returns>The rectangle the event has covered</returns>
    public override Rect RenderEvent(Rect myArea) {
      USFadeCameraEvent cameraEvent = TargetEvent as USFadeCameraEvent;
      if(cameraEvent == null) {
        Debug.LogWarning(
          "Trying to render an event as a USFadeCameraEvent, but it is a: " +
          TargetEvent.GetType().ToString()
        );
        return myArea;
      }

      myArea = DrawDurationDefinedBox(myArea);

      using(new GUIBeginArea(myArea)) {
        GUILayout.Label(GetReadableEventName(), DefaultLabel);

        Rect box = GUILayoutUtility.GetRect(0.0f, 1000.0f, 0.0f, 1000.0f);
        if((box.width > 1) && (box.height > 1)) {
          box.y += 2;
          box.height -= 2;

          GUI.Box(box, getFadeChart(cameraEvent, (int)box.width, (int)box.height));
        }
      }

      return myArea;
    }

    /// <summary>Provides a fade chart for the current GUI event</summary>
    /// <param name="guiEvent">GUI event for which a fade chart will be provided</param>
    /// <param name="width">Fade chart width</param>
    /// <param name="height">Fade chart height</param>
    /// <returns>The fade chart for the specified event and size</returns>
    private Texture2D getFadeChart(USFadeCameraEvent guiEvent, int width, int height) {
      bool refreshNeeded =
        (this.cachedFadeChart == null) ||
        (width != this.cachedWidth) ||
        (height != this.cachedHeight) ||
        (guiEvent.LeftFadeLevel != this.cachedLeftFadeLevel) ||
        (guiEvent.RightFadeLevel != this.cachedRightFadeLevel);

      if(refreshNeeded) {
        this.cachedFadeChart = new Texture2D(width, height, TextureFormat.ARGB32, false);

        Color blankColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
        for(int x = 0; x < width; ++x) {
          float interpolationPoint = (float)x / width;
          Color filledColor = new Color(
            1.0f, 1.0f, 1.0f,
            Mathf.Lerp(guiEvent.LeftFadeLevel, guiEvent.RightFadeLevel, interpolationPoint)
          );

          int split = (int)Mathf.Lerp(
            guiEvent.LeftFadeLevel * height, guiEvent.RightFadeLevel * height, interpolationPoint
          );
          for(int y = 0; y < split; ++y) {
            this.cachedFadeChart.SetPixel(x, y, filledColor);
          }
          for(int y = split; y < height; ++y) {
            this.cachedFadeChart.SetPixel(x, y, blankColor);
          }

          this.cachedWidth = width;
          this.cachedHeight = height;
          this.cachedLeftFadeLevel = guiEvent.LeftFadeLevel;
          this.cachedRightFadeLevel = guiEvent.RightFadeLevel;
        }

        this.cachedFadeChart.Apply(false);
      }

      return this.cachedFadeChart;
    }

    /// <summary>Fade chart texture created for the event</summary>
    private Texture2D cachedFadeChart;
    /// <summary>Width for which the current fade chart was created</summary>
    private int cachedWidth;
    /// <summary>Height for which the current fade chart was created</summary>
    private int cachedHeight;
    /// <summary>Starting fade level for which the current fade chart was created</summary>
    private float cachedLeftFadeLevel;
    /// <summary>Ending fade level for which the current fade chart was created</summary>
    private float cachedRightFadeLevel;

  }

} // namespace Framework.Camera

#endif // HAVE_USEQUENCER