#if HAVE_NODECANVAS

using System;

using UnityEngine;

#if HAVE_STANDARDEFFECTS
using UnityStandardAssets.ImageEffects;
#endif

using ParadoxNotion.Design;
using NodeCanvas.Framework;

namespace Framework.Cameras {

  /// <summary>Adjusts the blur on a camera's image</summary>
  [Category("Camera")]
  [Description("Adjusts the blur on a camera's image")]
  public class BlurCameraTask : ActionTask {

    /// <summary>Camera whose blur level will be adjusted</summary>
    [RequiredField]
    public BBParameter<Camera> Camera;

    /// <summary>Duration of the action in seconds</summary>
    public float Length;

    /// <summary>Blur size the camera will begin with</summary>
    public float StartBlurLevel;
    /// <summary>Blur size the camera will end with</summary>
    public float TargetBlurLevel;

    /// <summary>Number of iterations the camera will begin with</summary>
    public int StartIterationCount;
    /// <summary>Number of iterations  the camera will end with</summary>
    public int TargetIterationCount;

    /// <summary>Summary of what this action does</summary>
    protected override string info {
      get {
        if(this.Length == 0.0f) {
          if(this.TargetBlurLevel == 0.0f) {
            return "Set Camera Unblurred";
          } else if(this.TargetBlurLevel == 1.0f) {
            return "Set Camera Fully Blurred";
          } else {
            return "Set Camera Blurred " + this.TargetBlurLevel.ToString();
          }
        } else if(this.TargetBlurLevel > this.StartBlurLevel) {
          return "Camera Slowly Blurrs";
        } else if(this.TargetBlurLevel < this.StartBlurLevel) {
          return "Camera Slowly Unblurrs";
        } else {
          return "Camera Stays Blurred";
        }
      }
    }

    /// <summary>Called once when the action is executed</summary>
    protected override void OnExecute() {
      bool enable = (this.StartBlurLevel > 0.0f) || (this.TargetBlurLevel > 0.0f);

#if HAVE_STANDARDEFFECTS
      if(this.optimizedBlur != null) {
        this.optimizedBlur.enabled = enable;
      } else if(this.blur != null) {
        this.blur.enabled = enable;
      }
#endif // HAVE_STANDARDEFFECTS
#if HAVE_SUPERBLUR
      if (this.superBlur != null) {
        this.superBlur.enabled = enable;
      }
#endif // HAVE_SUPERBLUR
    }

    /// <summary>Called once before the action is executed for the first time</summary>
    /// <returns>An error message or null if no error occurred</returns>
    protected override string OnInit() {
      string error = base.OnInit();

      if(error == null) {
#if !HAVE_STANDARDEFFECTS && !HAVE_SUPERBLUR
        Debug.LogError(
          "Camera blur tasks will not function because no effects package " +
          "has been enabled. Set HAVE_STANDARDEFFECTS for standard Unity blur."
        );
#endif

        bool haveBlurEffect = false;

#if HAVE_STANDARDEFFECTS
        this.optimizedBlur = this.Camera.value.GetComponent<BlurOptimized>();
        if(this.optimizedBlur == null) {
          this.blur = this.Camera.value.GetComponent<Blur>();
          haveBlurEffect |= (this.blur != null);
        } else {
          haveBlurEffect = true;
        }
#endif // HAVE_STANDARDEFFECTS
#if HAVE_SUPERBLUR
        this.superBlur = this.Camera.value.GetComponent<SuperBlur.SuperBlur>();
        haveBlurEffect |= (this.superBlur != null);
#endif // HAVE_SUPERBLUR

        if (!haveBlurEffect) {
          Debug.LogError(
            "Camera '" + this.Camera.name + "' has none of the supported + enabled " +
            "blur filters. Camera blurring will not work."
          );
        }
      }

      return error;
    }

    /// <summary>
    ///   Called every frame, if and while the action is running and until it ends
    /// </summary>
    protected override void OnUpdate() {
#if HAVE_STANDARDEFFECTS || HAVE_SUPERBLUR
      float t = (elapsedTime / this.Length);

      float blurLevel = Mathf.Lerp(this.StartBlurLevel, this.TargetBlurLevel, t);
      blurLevel *= blurLevel;

      int iterationCount = Mathf.RoundToInt(
        Mathf.Lerp((float)this.StartIterationCount, (float)this.TargetIterationCount, t)
      );
#endif // HAVE_STANDARDEFFECT || HAVE_SUPERBLUR
#if HAVE_STANDARDEFFECTS
      if(this.optimizedBlur != null) {
        this.optimizedBlur.blurSize = blurLevel * 10.0f;
        this.optimizedBlur.blurIterations = iterationCount;
      } else if(this.blur != null) {
        this.blur.blurSpread = blurLevel;
        this.blur.iterations = iterationCount;
      }
#endif // HAVE_STANDARDEFFECTS
#if HAVE_SUPERBLUR
      if(this.superBlur != null) {
        this.superBlur.iterations = iterationCount;
        this.superBlur.interpolation = blurLevel;
      }
#endif // HAVE_SUPERBLUR

      if(elapsedTime >= this.Length) {
        EndAction();
      }
    }

    /// <summary>Called once when the task ends for any reason</summary>
    protected override void OnStop() {
      base.OnStop();

#if HAVE_STANDARDEFFECTS
      if(this.optimizedBlur != null) {
        this.optimizedBlur.blurSize = this.TargetBlurLevel * 10.0f;
        this.optimizedBlur.blurIterations = this.TargetIterationCount;

        if(this.TargetBlurLevel == 0.0f) {
          this.optimizedBlur.enabled = false;
        }

      } else if(this.blur != null) {
        this.blur.blurSpread = this.TargetBlurLevel;
        this.blur.iterations = this.TargetIterationCount;

        if(this.TargetBlurLevel == 0.0f) {
          this.blur.enabled = false;
        }
      }
#endif // HAVE_STANDARDEFFECTS
#if HAVE_SUPERBLUR
      if (this.superBlur != null) {
        this.superBlur.interpolation = this.TargetBlurLevel;
        this.superBlur.iterations = this.TargetIterationCount;

        if (this.TargetBlurLevel == 0.0f) {
          this.superBlur.enabled = false;
        }
      }
#endif // HAVE_SUPERBLUR
    }

#if HAVE_STANDARDEFFECTS
    /// <summary>Optimized camera blur filter</summary>
    [NonSerialized]
    private BlurOptimized optimizedBlur;
    /// <summary>Camera blur filter</summary>
    [NonSerialized]
    private Blur blur;
#endif // HAVE_STANDARDEFFECTS
#if HAVE_SUPERBLUR
    /// <summary>Free gaussian blur camera effect</summary>
    [NonSerialized]
    private SuperBlur.SuperBlur superBlur;
#endif // HAVE_SUPERBLUR

  }

} // namespace Framework.Cameras

#endif // HAVE_NODECANVAS && HAVE_STANDARDEFFECTS