using Sitecore.Common;
using Sitecore.Configuration;
using Sitecore.Data.Items;
using Sitecore.Data.Proxies;
using Sitecore.Diagnostics;
using Sitecore.Pipelines;
using Sitecore.SecurityModel;
using System;
using System.IO;

namespace Sitecore.Resources.Media
{
  public class Media : IPrototype<Sitecore.Resources.Media.Media>
  {
    protected const string GET_STREAM_PIPELINE_NAME = "getMediaStream";
    private MediaData mediaData;

    public Media()
    {
    }

    public Media(MediaData mediaData)
    {
      Assert.ArgumentNotNull((object) mediaData, nameof (mediaData));
      this.mediaData = mediaData;
    }

    public virtual string Extension
    {
      get
      {
        return this.MediaData.Extension;
      }
    }

    public virtual MediaData MediaData
    {
      get
      {
        return this.mediaData;
      }
    }

    public virtual string MimeType
    {
      get
      {
        return this.MediaData.MimeType;
      }
    }

    public virtual Sitecore.Resources.Media.Media Clone()
    {
      Assert.IsTrue(this.GetType() == typeof (Sitecore.Resources.Media.Media), "The Clone() method must be overridden to support prototyping.");
      return new Sitecore.Resources.Media.Media() { mediaData = this.mediaData };
    }

    public virtual void Initialize(MediaData innerData)
    {
      Assert.ArgumentNotNull((object) innerData, nameof (innerData));
      this.mediaData = innerData;
    }

    public virtual void GetMetaData(MediaMetaDataCollection metaData)
    {
      Assert.ArgumentNotNull((object) metaData, nameof (metaData));
      this.AddMetaData(metaData);
    }

    public virtual MediaStream GetStream()
    {
      return this.GetStream(new MediaOptions());
    }

    public virtual MediaStream GetStream(MediaOptions options)
    {
      Assert.ArgumentNotNull((object) options, nameof (options));
      MediaStream streamFromCache = this.GetStreamFromCache(options);
      if (streamFromCache != null)
        return streamFromCache;
      bool canBeCached;
      MediaStream streamFromPipeline = this.GetStreamFromPipeline(options, out canBeCached);
      if (streamFromPipeline == null)
        return (MediaStream) null;
      MediaStream cachedStream;
      if (canBeCached && this.AddStreamToCache(options, streamFromPipeline, out cachedStream))
        return cachedStream;
      return streamFromPipeline;
    }

    public virtual MediaStream GetThumbnailStream()
    {
      return this.GetStream(new MediaOptions()
      {
        Thumbnail = true
      });
    }

    public virtual void SetStream(MediaStream mediaStream)
    {
      Assert.ArgumentNotNull((object) mediaStream, nameof (mediaStream));
      this.MediaData.SetStream(mediaStream);
      this.UpdateMetaData(mediaStream);
    }

    public virtual void SetStream(Stream stream, string extension)
    {
      Assert.ArgumentNotNull((object) stream, nameof (stream));
      Assert.ArgumentNotNull((object) extension, nameof (extension));
      this.SetStream(new MediaStream(stream, extension, this.MediaData.MediaItem));
    }

    public virtual void ReleaseStream()
    {
      this.MediaData.ReleaseStream();
      this.ClearMetaData();
    }

    public virtual void UpdateMetaData(MediaStream mediaStream)
    {
      Assert.ArgumentNotNull((object) mediaStream, nameof (mediaStream));
      Item innerItem = this.MediaData.MediaItem.InnerItem;
      if (!innerItem.Paths.IsMediaItem)
        return;
      using (new EditContext(innerItem, SecurityCheck.Disable))
      {
        innerItem["extension"] = mediaStream.Extension;
        innerItem["mime type"] = mediaStream.MimeType;
        innerItem["size"] = mediaStream.Length.ToString();
        if (Settings.Media.AutoSetAlt)
          innerItem["Alt"] = innerItem.Name;
        MediaUrlOptions shellOptions = MediaUrlOptions.GetShellOptions();
        shellOptions.Thumbnail = true;
        shellOptions.Height = 16;
        shellOptions.Width = 16;
        Item realItem = ProxyManager.GetRealItem(innerItem, true);
        innerItem.Appearance.Icon = MediaManager.GetMediaUrl((MediaItem) realItem, shellOptions);
      }
    }

    protected virtual void AddMetaData(MediaMetaDataCollection metaData)
    {
      Assert.ArgumentNotNull((object) metaData, nameof (metaData));
    }

    protected virtual MediaStream GetStreamFromPipeline(MediaOptions options)
    {
      Assert.ArgumentNotNull((object) options, nameof (options));
      bool canBeCached;
      return this.GetStreamFromPipeline(options, out canBeCached);
    }

    protected virtual MediaStream GetStreamFromPipeline(MediaOptions options, out bool canBeCached)
    {
      Assert.IsNotNull((object) options, nameof (options));
      try
      {
        GetMediaStreamPipelineArgs streamPipelineArgs = new GetMediaStreamPipelineArgs(this.MediaData, options);
        CorePipeline.Run("getMediaStream", (PipelineArgs) streamPipelineArgs);
        canBeCached = true;
        return streamPipelineArgs.OutputStream;
      }
      catch (Exception ex)
      {
        Log.Error("Could not run the 'getMediaStream' pipeline for '" + this.MediaData.MediaItem.InnerItem.Paths.Path + "'. Original media data will be used.", ex, (object) this);
        canBeCached = false;
      }
      return this.MediaData.GetStream();
    }

    protected virtual void ClearMetaData()
    {
      this.ClearFields("extension", "mime type", "size");
    }

    protected void ClearFields(params string[] fieldNames)
    {
      Item innerItem = this.MediaData.MediaItem.InnerItem;
      using (new EditContext(innerItem, SecurityCheck.Disable))
      {
        foreach (string fieldName in fieldNames)
          innerItem[fieldName] = string.Empty;
      }
    }

    private bool AddStreamToCache(MediaOptions options, MediaStream mediaStream, out MediaStream cachedStream)
    {
      cachedStream = (MediaStream) null;
      try
      {
        return MediaManager.Cache.AddStream(this, options, mediaStream, out cachedStream);
      }
      catch (Exception ex)
      {
        Log.Error("Could not add media to cache. Media item id: " + (object) this.MediaData.MediaItem.InnerItem.ID, ex, (object) this);
        return false;
      }
    }

    private MediaStream GetStreamFromCache(MediaOptions options)
    {
      return MediaManager.Cache.GetStream(this, options);
    }
  }
}