using Sitecore.Common;
using Sitecore.Configuration;
using Sitecore.Data;
using Sitecore.Data.Fields;
using Sitecore.Data.Items;
using Sitecore.Diagnostics;
using Sitecore.IO;
using Sitecore.SecurityModel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web;

namespace Sitecore.Resources.Media
{
  public class MediaData : IPrototype<MediaData>
  {
    private string _dataFieldName = "blob";
    private MediaItem _mediaItem;
    private DateTime? updated;

    public MediaData()
    {
    }

    public MediaData(MediaItem mediaItem)
    {
      Assert.ArgumentNotNull((object) mediaItem, nameof (mediaItem));
      this.Initialize(mediaItem);
    }

    public virtual string DataFieldName
    {
      get
      {
        return this._dataFieldName;
      }
      set
      {
        Assert.ArgumentNotNullOrEmpty(value, nameof (value));
        this._dataFieldName = value;
      }
    }

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

    public virtual bool HasContent
    {
      get
      {
        if (this.HasFileContent)
          return true;
        Field field = this.MediaItem.InnerItem.Fields[this.DataFieldName];
        return field != null && field.HasBlobStream;
      }
    }

    public virtual bool HasFileContent
    {
      get
      {
        if (this.IsValidFilePath(this.MediaItem.FilePath))
          return FileUtil.FileExists(this.MediaItem.FilePath);
        return false;
      }
    }

    public virtual string MediaId
    {
      get
      {
        ID id = (ID) null;
        if (!string.IsNullOrEmpty(this.MediaItem.FilePath))
        {
          string lowerInvariant = this.MediaItem.FilePath.ToLowerInvariant();
          id = !Settings.Media.CacheFileMediaByModifiedDate ? MainUtil.GetMD5Hash(lowerInvariant) : MainUtil.GetMD5Hash(lowerInvariant + (object) File.GetLastWriteTimeUtc(FileUtil.MapPath(lowerInvariant)));
        }
        else
        {
          Field field = this._mediaItem.InnerItem.Fields[this.DataFieldName];
          if (field != null && MainUtil.IsID(field.Value))
            id = ID.Parse(field.Value);
        }
        if (!(id == (ID) null))
          return id.ToShortID().ToString().ToLowerInvariant();
        return string.Empty;
      }
    }

    public virtual MediaItem MediaItem
    {
      get
      {
        return this._mediaItem;
      }
    }

    public virtual string MimeType
    {
      get
      {
        return MediaManager.MimeResolver.GetMimeType(this.MediaItem);
      }
    }

    public DateTime Updated
    {
      get
      {
        if (!this.updated.HasValue)
        {
          Item innerItem = this.MediaItem.InnerItem;
          if (innerItem.Versions.Count > 0)
          {
            this.updated = new DateTime?(innerItem.Statistics.Updated);
          }
          else
          {
            Item[] versions = innerItem.Versions.GetVersions(true);
            this.updated = versions.Length <= 0 ? new DateTime?(DateTimeOffset.MinValue.UtcDateTime) : new DateTime?(((IEnumerable<Item>) versions).Select<Item, DateTime>((Func<Item, DateTime>) (item => item.Statistics.Updated)).Max<DateTime>());
          }
        }
        return this.updated.Value;
      }
    }

    public virtual MediaStream GetStream()
    {
      if (this.MediaItem.FileBased)
        return this.GetFileStream();
      return this.GetBlobStream();
    }

    public virtual MediaStream GetThumbnailStream()
    {
      return this.GetThumbnailStream(new TransformationOptions());
    }

    public virtual MediaStream GetThumbnailStream(TransformationOptions options)
    {
      Assert.ArgumentNotNull((object) options, nameof (options));
      ThumbnailGenerator thumbnailGenerator = MediaManager.Config.GetThumbnailGenerator(this.Extension);
      if (thumbnailGenerator == null)
        return (MediaStream) null;
      MediaStream stream = thumbnailGenerator.GetStream(this, options);
      if (stream != null)
        return stream;
      return MediaManager.Config.GetThumbnailGenerator("*")?.GetStream(this, options);
    }

    public virtual void Initialize(MediaItem mediaItem)
    {
      Assert.ArgumentNotNull((object) mediaItem, nameof (mediaItem));
      this._mediaItem = mediaItem;
    }

    public virtual void ReleaseStream()
    {
      Item innerItem = this._mediaItem.InnerItem;
      Field field = innerItem.Fields[this.DataFieldName];
      if (field == null || field.Value.IsNullOrEmpty())
        return;
      using (new EditContext(innerItem))
        innerItem.Fields[this.DataFieldName].Value = string.Empty;
    }

    public virtual void SetStream(MediaStream mediaStream)
    {
      Assert.ArgumentNotNull((object) mediaStream, nameof (mediaStream));
      if (mediaStream.MediaItem.FileBased)
        this.SetFileStream(mediaStream);
      else
        this.SetBlobStream(mediaStream);
    }

    public virtual MediaData Clone()
    {
      Assert.IsTrue(this.GetType() == typeof (MediaData), "The Clone() method must be overriden to support prototyping.");
      return new MediaData()
      {
        _mediaItem = this._mediaItem,
        _dataFieldName = this._dataFieldName
      };
    }

    protected virtual MediaStream GetBlobStream()
    {
      Field field = this.MediaItem.InnerItem.Fields[this.DataFieldName];
      if (field == null)
        return (MediaStream) null;
      Stream blobStream = field.GetBlobStream();
      if (blobStream == null)
        return (MediaStream) null;
      try
      {
        return new MediaStream(blobStream, this.Extension, this.MediaItem);
      }
      catch
      {
        return (MediaStream) null;
      }
    }

    protected virtual MediaStream GetFileStream()
    {
      string filePath = this.MediaItem.FilePath;
      if (string.IsNullOrEmpty(filePath) || filePath.Contains("~"))
        return (MediaStream) null;
      if (!this.IsValidFilePath(filePath))
        return (MediaStream) null;
      if (!this.IsValidFilePath(filePath))
        return (MediaStream) null;
      string str = FileUtil.MapPath(filePath);
      if (!FileUtil.FileExists(str))
        return (MediaStream) null;
      return new MediaStream((Stream) File.Open(str, FileMode.Open, FileAccess.Read, FileShare.Read), this.Extension, this.MediaItem);
    }

    protected virtual bool IsValidFilePath(string filePath)
    {
      try
      {
        return !string.IsNullOrEmpty(filePath) && MainUtil.MapPath(filePath).StartsWith(MainUtil.MapPath(Settings.Media.FileFolder), StringComparison.InvariantCultureIgnoreCase);
      }
      catch (HttpException ex)
      {
        return false;
      }
      catch (NotSupportedException ex)
      {
        return false;
      }
    }

    protected virtual void SetBlobStream(MediaStream mediaStream)
    {
      Assert.ArgumentNotNull((object) mediaStream, nameof (mediaStream));
      Assert.IsTrue((mediaStream.AllowDatabaseStorage ? 1 : 0) != 0, "Media larger than {0} bytes can not be stored in database blob fields. Use file storage instead.", (object) Settings.Media.MaxSizeInDatabase);
      Item innerItem = this.MediaItem.InnerItem;
      Field field = innerItem.Fields[this.DataFieldName];
      if (field == null)
        return;
      using (new EditContext(innerItem))
        field.SetBlobStream(mediaStream.Stream);
    }

    protected virtual void SetFileStream(MediaStream mediaStream)
    {
      Assert.ArgumentNotNull((object) mediaStream, nameof (mediaStream));
      MediaItem mediaItem = mediaStream.MediaItem;
      Assert.IsNotNull((object) mediaItem, "No media item in media stream.");
      string str = mediaItem.FilePath;
      if (string.IsNullOrEmpty(str))
      {
        str = MediaPathManager.GetMediaFilePath(mediaItem.InnerItem.Paths.Path, mediaStream.Extension);
        using (new SecurityDisabler())
        {
          using (new EditContext(mediaItem.InnerItem))
            mediaItem.FilePath = str;
        }
      }
      Assert.IsNotNullOrEmpty(str, "Empty file path in file based media item.");
      Assert.IsFalse(str.Contains("~"), "A file based media destination path may not contain a '~' character.");
      FileUtil.EnsureFileFolder(str);
      using (FileStream fileStream = File.Open(FileUtil.MapPath(str), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None))
      {
        Stream stream = mediaStream.Stream;
        if (stream.CanSeek)
          stream.Seek(0L, SeekOrigin.Begin);
        FileUtil.CopyStream(stream, (Stream) fileStream, Settings.Media.StreamBufferSize);
      }
    }
  }
}