TLSharp/TLSharp.Core/Utils/UploadHelper.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
using TeleSharp.TL.Upload;

namespace TLSharp.Core.Utils
{
    public static class UploadHelper
    {
        private static string GetFileHash(byte[] data)
        {
            string md5_checksum;
            using (var md5 = MD5.Create())
            {
                var hash = md5.ComputeHash(data);
                var hashResult = new StringBuilder(hash.Length * 2);

                foreach (var t in hash)
                    hashResult.Append(t.ToString("x2"));

                md5_checksum = hashResult.ToString();
            }

            return md5_checksum;
        }

        public static async Task<TLAbsInputFile> UploadFile(this TelegramClient client, string name,
            StreamReader reader)
        {
            const long tenMb = 10 * 1024 * 1024;
            return await UploadFile(name, reader, client, reader.BaseStream.Length >= tenMb);
        }

        private static byte[] GetFile(StreamReader reader)
        {
            var file = new byte[reader.BaseStream.Length];

            using (reader)
            {
                reader.BaseStream.Read(file, 0, (int) reader.BaseStream.Length);
            }

            return file;
        }

        private static Queue<byte[]> GetFileParts(byte[] file)
        {
            var fileParts = new Queue<byte[]>();

            const int maxFilePart = 512 * 1024;

            using (var stream = new MemoryStream(file))
            {
                while (stream.Position != stream.Length)
                    if (stream.Length - stream.Position > maxFilePart)
                    {
                        var temp = new byte[maxFilePart];
                        stream.Read(temp, 0, maxFilePart);
                        fileParts.Enqueue(temp);
                    }
                    else
                    {
                        var length = stream.Length - stream.Position;
                        var temp = new byte[length];
                        stream.Read(temp, 0, (int) length);
                        fileParts.Enqueue(temp);
                    }
            }

            return fileParts;
        }

        private static async Task<TLAbsInputFile> UploadFile(string name, StreamReader reader,
            TelegramClient client, bool isBigFileUpload)
        {
            var file = GetFile(reader);
            var fileParts = GetFileParts(file);

            var partNumber = 0;
            var partsCount = fileParts.Count;
            var file_id = BitConverter.ToInt64(Helpers.GenerateRandomBytes(8), 0);
            while (fileParts.Count != 0)
            {
                var part = fileParts.Dequeue();

                if (isBigFileUpload)
                    await client.SendRequestAsync<bool>(new TLRequestSaveBigFilePart
                    {
                        file_id = file_id,
                        file_part = partNumber,
                        bytes = part,
                        file_total_parts = partsCount
                    });
                else
                    await client.SendRequestAsync<bool>(new TLRequestSaveFilePart
                    {
                        file_id = file_id,
                        file_part = partNumber,
                        bytes = part
                    });
                partNumber++;
            }

            if (isBigFileUpload)
                return new TLInputFileBig
                {
                    id = file_id,
                    name = name,
                    parts = partsCount
                };
            return new TLInputFile
            {
                id = file_id,
                name = name,
                parts = partsCount,
                md5_checksum = GetFileHash(file)
            };
        }
    }
}