context: using AVOSCloud.Internal;
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using System.Net;
  using System.Text;
  using System.Threading;
  using System.Threading.Tasks;
  using Windows.Storage;
  
  namespace AVOSCloud
  {
      public class AVFile
      {
          private object mutex = new object();
          private TaskQueue taskQueue = new TaskQueue();
          private int chunkBits = 16;
          private int chunkSize = 65536;
          private IList<QiniuBlock> qiniuBlocks = (IList<QiniuBlock>) new List<QiniuBlock>();
          internal static string UP_HOST = "http://upload.qiniu.com";
          private static int BLOCKSIZE = 4194304;
  
          private static readonly Dictionary<string, string> MIMETypesDictionary = new Dictionary<string, string>()
          {
              {
                  "ai",
                  "application/postscript"
              },
              {
                  "aif",
                  "audio/x-aiff"
              },
              {
                  "aifc",
                  "audio/x-aiff"
              },
              {
                  "aiff",
                  "audio/x-aiff"
              },
              {
                  "asc",
                  "text/plain"
              },
              {
                  "atom",
                  "application/atom+xml"
              },
              {
                  "au",
                  "audio/basic"
              },
              {
                  "avi",
                  "video/x-msvideo"
              },
              {
                  "bcpio",
                  "application/x-bcpio"
              },
              {
                  "bin",
                  "application/octet-stream"
              },
              {
                  "bmp",
                  "image/bmp"
              },
              {
                  "cdf",
                  "application/x-netcdf"
              },
              {
                  "cgm",
                  "image/cgm"
              },
              {
                  "class",
                  "application/octet-stream"
              },
              {
                  "cpio",
                  "application/x-cpio"
              },
              {
                  "cpt",
                  "application/mac-compactpro"
              },
              {
                  "csh",
                  "application/x-csh"
              },
              {
                  "css",
                  "text/css"
              },
              {
                  "dcr",
                  "application/x-director"
              },
              {
                  "dif",
                  "video/x-dv"
              },
              {
                  "dir",
                  "application/x-director"
              },
              {
                  "djv",
                  "image/vnd.djvu"
              },
              {
                  "djvu",
                  "image/vnd.djvu"
              },
              {
                  "dll",
                  "application/octet-stream"
              },
              {
                  "dmg",
                  "application/octet-stream"
              },
              {
                  "dms",
                  "application/octet-stream"
              },
              {
                  "doc",
                  "application/msword"
              },
              {
                  "docx",
                  "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
              },
              {
                  "dotx",
                  "application/vnd.openxmlformats-officedocument.wordprocessingml.template"
              },
              {
                  "docm",
                  "application/vnd.ms-word.document.macroEnabled.12"
              },
              {
                  "dotm",
                  "application/vnd.ms-word.template.macroEnabled.12"
              },
              {
                  "dtd",
                  "application/xml-dtd"
              },
              {
                  "dv",
                  "video/x-dv"
              },
              {
                  "dvi",
                  "application/x-dvi"
              },
              {
                  "dxr",
                  "application/x-director"
              },
              {
                  "eps",
                  "application/postscript"
              },
              {
                  "etx",
                  "text/x-setext"
              },
              {
                  "exe",
                  "application/octet-stream"
              },
              {
                  "ez",
                  "application/andrew-inset"
              },
              {
                  "gif",
                  "image/gif"
              },
              {
                  "gram",
                  "application/srgs"
              },
              {
                  "grxml",
                  "application/srgs+xml"
              },
              {
                  "gtar",
                  "application/x-gtar"
              },
              {
                  "hdf",
                  "application/x-hdf"
              },
              {
                  "hqx",
                  "application/mac-binhex40"
              },
              {
                  "htm",
                  "text/html"
              },
              {
                  "html",
                  "text/html"
              },
              {
                  "ice",
                  "x-conference/x-cooltalk"
              },
              {
                  "ico",
                  "image/x-icon"
              },
              {
                  "ics",
                  "text/calendar"
              },
              {
                  "ief",
                  "image/ief"
              },
              {
                  "ifb",
                  "text/calendar"
              },
              {
                  "iges",
                  "model/iges"
              },
              {
                  "igs",
                  "model/iges"
              },
              {
                  "jnlp",
                  "application/x-java-jnlp-file"
              },
              {
                  "jp2",
                  "image/jp2"
              },
              {
                  "jpe",
                  "image/jpeg"
              },
              {
                  "jpeg",
                  "image/jpeg"
              },
              {
                  "jpg",
                  "image/jpeg"
              },
              {
                  "js",
                  "application/x-javascript"
              },
              {
                  "kar",
                  "audio/midi"
              },
              {
                  "latex",
                  "application/x-latex"
              },
              {
                  "lha",
                  "application/octet-stream"
              },
              {
                  "lzh",
                  "application/octet-stream"
              },
              {
                  "m3u",
                  "audio/x-mpegurl"
              },
              {
                  "m4a",
                  "audio/mp4a-latm"
              },
              {
                  "m4b",
                  "audio/mp4a-latm"
              },
              {
                  "m4p",
                  "audio/mp4a-latm"
              },
              {
                  "m4u",
                  "video/vnd.mpegurl"
              },
              {
                  "m4v",
                  "video/x-m4v"
              },
              {
                  "mac",
                  "image/x-macpaint"
              },
              {
                  "man",
                  "application/x-troff-man"
              },
              {
                  "mathml",
                  "application/mathml+xml"
              },
              {
                  "me",
                  "application/x-troff-me"
              },
              {
                  "mesh",
                  "model/mesh"
              },
              {
                  "mid",
                  "audio/midi"
              },
              {
                  "midi",
                  "audio/midi"
              },
              {
                  "mif",
                  "application/vnd.mif"
              },
              {
                  "mov",
                  "video/quicktime"
              },
              {
                  "movie",
                  "video/x-sgi-movie"
              },
              {
                  "mp2",
                  "audio/mpeg"
              },
              {
                  "mp3",
                  "audio/mpeg"
              },
              {
                  "mp4",
                  "video/mp4"
              },
              {
                  "mpe",
                  "video/mpeg"
              },
              {
                  "mpeg",
                  "video/mpeg"
              },
              {
                  "mpg",
                  "video/mpeg"
              },
              {
                  "mpga",
                  "audio/mpeg"
              },
              {
                  "ms",
                  "application/x-troff-ms"
              },
              {
                  "msh",
                  "model/mesh"
              },
              {
                  "mxu",
                  "video/vnd.mpegurl"
              },
              {
                  "nc",
                  "application/x-netcdf"
              },
              {
                  "oda",
                  "application/oda"
              },
              {
                  "ogg",
                  "application/ogg"
              },
              {
                  "pbm",
                  "image/x-portable-bitmap"
              },
              {
                  "pct",
                  "image/pict"
              },
              {
                  "pdb",
                  "chemical/x-pdb"
              },
              {
                  "pdf",
                  "application/pdf"
              },
              {
                  "pgm",
                  "image/x-portable-graymap"
              },
              {
                  "pgn",
                  "application/x-chess-pgn"
              },
              {
                  "pic",
                  "image/pict"
              },
              {
                  "pict",
                  "image/pict"
              },
              {
                  "png",
                  "image/png"
              },
              {
                  "pnm",
                  "image/x-portable-anymap"
              },
              {
                  "pnt",
                  "image/x-macpaint"
              },
              {
                  "pntg",
                  "image/x-macpaint"
              },
              {
                  "ppm",
                  "image/x-portable-pixmap"
              },
              {
                  "ppt",
                  "application/vnd.ms-powerpoint"
              },
              {
                  "pptx",
                  "application/vnd.openxmlformats-officedocument.presentationml.presentation"
              },
              {
                  "potx",
                  "application/vnd.openxmlformats-officedocument.presentationml.template"
              },
              {
                  "ppsx",
                  "application/vnd.openxmlformats-officedocument.presentationml.slideshow"
              },
              {
                  "ppam",
                  "application/vnd.ms-powerpoint.addin.macroEnabled.12"
              },
              {
                  "pptm",
                  "application/vnd.ms-powerpoint.presentation.macroEnabled.12"
              },
              {
                  "potm",
                  "application/vnd.ms-powerpoint.template.macroEnabled.12"
              },
              {
                  "ppsm",
                  "application/vnd.ms-powerpoint.slideshow.macroEnabled.12"
              },
              {
                  "ps",
                  "application/postscript"
              },
              {
                  "qt",
                  "video/quicktime"
              },
              {
                  "qti",
                  "image/x-quicktime"
              },
              {
                  "qtif",
                  "image/x-quicktime"
              },
              {
                  "ra",
                  "audio/x-pn-realaudio"
              },
              {
                  "ram",
                  "audio/x-pn-realaudio"
              },
              {
                  "ras",
                  "image/x-cmu-raster"
              },
              {
                  "rdf",
                  "application/rdf+xml"
              },
              {
                  "rgb",
                  "image/x-rgb"
              },
              {
                  "rm",
                  "application/vnd.rn-realmedia"
              },
              {
                  "roff",
                  "application/x-troff"
              },
              {
                  "rtf",
                  "text/rtf"
              },
              {
                  "rtx",
                  "text/richtext"
              },
              {
                  "sgm",
                  "text/sgml"
              },
              {
                  "sgml",
                  "text/sgml"
              },
              {
                  "sh",
                  "application/x-sh"
              },
              {
                  "shar",
                  "application/x-shar"
              },
              {
                  "silo",
                  "model/mesh"
              },
              {
                  "sit",
                  "application/x-stuffit"
              },
              {
                  "skd",
                  "application/x-koan"
              },
              {
                  "skm",
                  "application/x-koan"
              },
              {
                  "skp",
                  "application/x-koan"
              },
              {
                  "skt",
                  "application/x-koan"
              },
              {
                  "smi",
                  "application/smil"
              },
              {
                  "smil",
                  "application/smil"
              },
              {
                  "snd",
                  "audio/basic"
              },
              {
                  "so",
                  "application/octet-stream"
              },
              {
                  "spl",
                  "application/x-futuresplash"
              },
              {
                  "src",
                  "application/x-wais-source"
              },
              {
                  "sv4cpio",
                  "application/x-sv4cpio"
              },
              {
                  "sv4crc",
                  "application/x-sv4crc"
              },
              {
                  "svg",
                  "image/svg+xml"
              },
              {
                  "swf",
                  "application/x-shockwave-flash"
              },
              {
                  "t",
                  "application/x-troff"
              },
              {
                  "tar",
                  "application/x-tar"
              },
              {
                  "tcl",
                  "application/x-tcl"
              },
              {
                  "tex",
                  "application/x-tex"
              },
              {
                  "texi",
                  "application/x-texinfo"
              },
              {
                  "texinfo",
                  "application/x-texinfo"
              },
              {
                  "tif",
                  "image/tiff"
              },
              {
                  "tiff",
                  "image/tiff"
              },
              {
                  "tr",
                  "application/x-troff"
              },
              {
                  "tsv",
                  "text/tab-separated-values"
              },
              {
                  "txt",
                  "text/plain"
              },
              {
                  "ustar",
                  "application/x-ustar"
              },
              {
                  "vcd",
                  "application/x-cdlink"
              },
              {
                  "vrml",
                  "model/vrml"
              },
              {
                  "vxml",
                  "application/voicexml+xml"
              },
              {
                  "wav",
                  "audio/x-wav"
              },
              {
                  "wbmp",
                  "image/vnd.wap.wbmp"
              },
              {
                  "wbmxl",
                  "application/vnd.wap.wbxml"
              },
              {
                  "wml",
                  "text/vnd.wap.wml"
              },
              {
                  "wmlc",
                  "application/vnd.wap.wmlc"
              },
              {
                  "wmls",
                  "text/vnd.wap.wmlscript"
              },
              {
                  "wmlsc",
                  "application/vnd.wap.wmlscriptc"
              },
              {
                  "wrl",
                  "model/vrml"
              },
              {
                  "xbm",
                  "image/x-xbitmap"
              },
              {
                  "xht",
                  "application/xhtml+xml"
              },
              {
                  "xhtml",
                  "application/xhtml+xml"
              },
              {
                  "xls",
                  "application/vnd.ms-excel"
              },
              {
                  "xml",
                  "application/xml"
              },
              {
                  "xpm",
                  "image/x-xpixmap"
              },
              {
                  "xsl",
                  "application/xml"
              },
              {
                  "xlsx",
                  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
              },
              {
                  "xltx",
                  "application/vnd.openxmlformats-officedocument.spreadsheetml.template"
              },
              {
                  "xlsm",
                  "application/vnd.ms-excel.sheet.macroEnabled.12"
              },
              {
                  "xltm",
                  "application/vnd.ms-excel.template.macroEnabled.12"
              },
              {
                  "xlam",
                  "application/vnd.ms-excel.addin.macroEnabled.12"
              },
              {
                  "xlsb",
                  "application/vnd.ms-excel.sheet.binary.macroEnabled.12"
              },
              {
                  "xslt",
                  "application/xslt+xml"
              },
              {
                  "xul",
                  "application/vnd.mozilla.xul+xml"
              },
              {
                  "xwd",
                  "image/x-xwindowdump"
              },
              {
                  "xyz",
                  "chemical/x-xyz"
              },
              {
                  "zip",
                  "application/zip"
              }
          };
  
          private const int blockBits = 22;
          private const int blockMashk = 4194303;
          private const int TryTimes = 3;
          private string name;
          private Uri uri;
          private string token;
          private string bucket;
          private string bucketId;
          private bool isExternal;
          private Stream dataStream;
          private string objectId;
          private IDictionary<string, object> metaData;
  
          public bool IsDirty
          {
              get
              {
                  lock (this.mutex)
                      return this.dataStream != null && this.objectId == null;
              }
          }
  
          [AVFieldName("name")]
          public string Name
          {
              get
              {
                  lock (this.mutex)
                      return this.name;
              }
          }
  
          [AVFieldName("url")]
          public Uri Url
          {
              get
              {
                  lock (this.mutex)
                      return this.uri;
              }
          }
  
          public bool IsExternal
          {
              get { return this.isExternal; }
          }
  
          public IDictionary<string, object> MetaData
          {
              get { return this.metaData; }
          }
  
          public string ObjectId
          {
              get
              {
                  lock (this.mutex)
                      return this.objectId;
              }
          }
  
          public byte[] DataByte
          {
              get
              {
                  byte[] buffer = new byte[16384];
                  if (this.dataStream == null)
                      return buffer;
                  using (MemoryStream memoryStream = new MemoryStream())
                  {
                      this.dataStream.Seek(0L, SeekOrigin.Begin);
                      int count;
                      while ((count = this.dataStream.Read(buffer, 0, buffer.Length)) > 0)
                          memoryStream.Write(buffer, 0, count);
                      return memoryStream.ToArray();
                  }
              }
          }
  
          public string LocalPath { get; private set; }
  
          internal long Size
          {
              get { return long.Parse(this.MetaData["size"].ToString()); }
          }
  
          internal string CloudName
          {
              get { return this.GenerateLocalFileName(); }
          }
  
          internal AVFile(string name, Uri uri)
          {
              this.name = name;
              this.uri = uri;
          }
  
          public AVFile(string name, string url)
          {
              this.isExternal = true;
              this.name = name;
              this.uri = new Uri(url);
          }
  
          public AVFile(string name, byte[] data)
              : this(name, (Stream) new MemoryStream(data), (IDictionary<string, object>) new Dictionary<string, object>()
                  )
          {
          }
  
          public AVFile(string name, byte[] data, IDictionary<string, object> metaData)
              : this(name, (Stream) new MemoryStream(data), metaData)
          {
          }
  
          public AVFile(string name, Stream data, IDictionary<string, object> metaData)
          {
              this.name = name;
              this.dataStream = data;
              this.metaData = metaData;
          }
  
          public AVFile(string name, Stream data)
              : this(name, data, (IDictionary<string, object>) new Dictionary<string, object>())
          {
          }
  
          internal AVFile(string name, string url, IDictionary<string, object> metaData)
          {
              this.name = name;
              this.uri = new Uri(url);
              this.metaData = metaData;
          }
  
          private static string GetMIMEType(string fileName)
          {
              try
              {
                  string key = Path.GetExtension(fileName).Remove(0, 1);
                  if (!AVFile.MIMETypesDictionary.ContainsKey(key))
                      return "unknown/unknown";
                  else
                      return AVFile.MIMETypesDictionary[key];
              }
              catch
              {
                  return "unknown/unknown";
              }
          }
  
          internal void MergeFromJSON(IDictionary<string, object> jsonData)
          {
              lock (this.mutex)
              {
                  string local_0 = jsonData["url"] as string;
                  this.uri = new Uri(local_0, UriKind.Absolute);
                  this.bucketId = this.FetchBucketId(local_0);
                  this.token = jsonData["token"] as string;
                  this.bucket = jsonData["bucket"] as string;
                  this.objectId = jsonData["objectId"] as string;
              }
          }
  
          private string FetchBucketId(string url)
          {
              string[] strArray = url.Split('/');
              return strArray[strArray.Length - 1];
          }
  
          internal IDictionary<string, object> GetMetaData()
          {
              IDictionary<string, object> dic = (IDictionary<string, object>) new Dictionary<string, object>();
              if (this.metaData != null)
              {
                  foreach (
                      KeyValuePair<string, object> keyValuePair in
                          (IEnumerable<KeyValuePair<string, object>>) this.metaData)
                      dic.Add(keyValuePair.Key, keyValuePair.Value);
              }
              this.MergeDic(dic, "size", (object) this.dataStream.Length);
              this.MergeDic(dic, "_checksum", (object) AVFile.GetMD5Code(this.dataStream));
              if (AVUser.CurrentUser != null && AVUser.CurrentUser.ObjectId != null)
                  this.MergeDic(dic, "owner", (object) AVUser.CurrentUser.ObjectId);
              if (this.IsExternal)
                  this.MergeDic(dic, "__source", (object) "external");
              return dic;
          }
  
          internal void MergeDic(IDictionary<string, object> dic, string key, object value)
          {
              if (dic.ContainsKey(key))
                  dic[key] = value;
              else
                  dic.Add(key, value);
          }
  
          internal static string GetMD5Code(Stream data)
          {
              byte[] hash = new MD5CryptoServiceProvider().ComputeHash(data);
              StringBuilder stringBuilder = new StringBuilder();
              for (int index = 0; index < hash.Length; ++index)
                  stringBuilder.Append(hash[index].ToString("x2"));
              return ((object) stringBuilder).ToString();
          }
  
          public Task SaveAsync()
          {
              return this.SaveAsync((IProgress<AVUploadProgressEventArgs>) null, CancellationToken.None);
          }
  
          public Task SaveAsync(CancellationToken cancellationToken)
          {
              return this.SaveAsync((IProgress<AVUploadProgressEventArgs>) null, cancellationToken);
          }
  
          public Task SaveAsync(IProgress<AVUploadProgressEventArgs> progress)
          {
              return this.SaveAsync(progress, CancellationToken.None);
          }
  
          public Task SaveAsync(IProgress<AVUploadProgressEventArgs> progress, CancellationToken cancellationToken)
          {
              return
                  this.taskQueue.Enqueue<Task>(
                      (Func<Task, Task>) (toAwait => this.SaveAsync(toAwait, progress, cancellationToken)),
                      cancellationToken);
          }
  
          private Task SaveAsync(Task toAwait, IProgress<AVUploadProgressEventArgs> progress,
              CancellationToken cancellationToken)
          {
              lock (this.mutex)
              {
                  string currentSessionToken = AVUser.CurrentSessionToken;
              }
              long position = this.dataStream.Position;
              return toAwait.OnSuccess<Task>(t => {
                  Task task1 = null;
                  lock (this.mutex)
                  {
                      if (!this.IsDirty)
                      {
                          task1 = Task.FromResult<int>(0);
                      }
                      else
                      {
                          string str = Guid.NewGuid().ToString();
                          str = string.Concat(str, Path.GetExtension(this.name));
                          task1 = this.GetQiniuToken(str, cancellationToken).ContinueWith(s => {
                              this.MergeFromJSON(s.Result.Item2);
                              return this.ResumableUploadToQiniu(progress, str, cancellationToken);
                          }, cancellationToken).Unwrap().ContinueWith<Task>(d => {
                              Task task = null;
                              task = (d.Result.Item1 == HttpStatusCode.OK ? Task.FromResult<int>(0) : this.DeleteAsync(cancellationToken));
                              return task;
                          }, cancellationToken).Unwrap();
                      }
                  }
                  return task1;
              }).Unwrap().ContinueWith<Task>((Task t) => {
                  if ((t.IsFaulted || t.IsCanceled) && this.dataStream.CanSeek)
                  {
                      this.dataStream.Seek(position, SeekOrigin.Begin);
                  }
                  return t;
              }, cancellationToken).Unwrap();
          }
  
          public Task DeleteAsync()
          {
              return this.DeleteAsync(CancellationToken.None);
          }
  
          public Task DownloadAsync()
          {
              return this.DownloadAsync(string.Empty, (IProgress<AVDownloadProgressEventArgs>) null,
                  CancellationToken.None);
          }
  
          public Task DownloadAsync(IProgress<AVDownloadProgressEventArgs> progress)
          {
              return this.DownloadAsync(string.Empty, progress, CancellationToken.None);
          }
  
          public Task DownloadAsync(string fileRename, IProgress<AVDownloadProgressEventArgs> progress,
              CancellationToken cancellationToken)
          {
              long fileSize = long.Parse(this.MetaData["size"].ToString());
              MemoryStream ms = new MemoryStream();
              this.SetChunkStrategy();
              IList<Tuple<long, long>> downloadChunks = this.GetDownloadChunks(fileSize, this.chunkSize, 0L);
              double completeCount = 0.0;
              double chunkCount = (double) downloadChunks.Count;
              Action<byte[]> afterLast = (Action<byte[]>) (chunkData =>
              {
                  ms.Write(chunkData, 0, chunkData.Length);
                  lock (this.mutex)
                  {
                      ++completeCount;
                      if (progress == null)
                          return;
                      progress.Report(new AVDownloadProgressEventArgs()
                      {
                          Progress = this.CalcProgress(completeCount, chunkCount)
                      });
                  }
              });
              return
                  InternalExtensions.Chaining<Tuple<long, long>, byte[]>((IEnumerable<Tuple<long, long>>) downloadChunks,
                      new Func<Tuple<long, long>, Task<byte[]>>(this.DownloadChunkAsync),
                      (Func<byte[], Tuple<long, long>, Tuple<long, long>>) null, afterLast, (byte[]) null)
                      .ContinueWith((Action<Task<IEnumerable<byte[]>>>) (s =>
                      {
                          long length = ms.Length;
                          this.dataStream = (Stream) ms;
                      }));
          }
  
          private double CalcProgress(double already, double total)
          {
              return Math.Round(1.0*already/total, 3);
          }
  
          private IList<Tuple<long, long>> GetDownloadChunks(long fileSize, int chunkSize, long startPosition)
          {
              IList<Tuple<long, long>> list = (IList<Tuple<long, long>>) new List<Tuple<long, long>>();
              long num1 = (fileSize + (long) chunkSize + 1L)/(long) chunkSize;
  
gt:             for (int index = 0; (long) index < num1; ++index)