using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Ips.Library.Basic
{
    public static class CompressionUtil
    {
        public static byte[] CompressGZip(string source)
        {
            byte[] stringAsBytes = Encoding.Default.GetBytes(source);
            using (var memoryStream = new MemoryStream())
            {
                using (var zipStream = new GZipStream(memoryStream, CompressionMode.Compress))
                {
                    zipStream.Write(stringAsBytes, 0, stringAsBytes.Length);
                    zipStream.Close();
                    return (memoryStream.ToArray());
                }
            }
        }

        public static byte[] CompressGZip(string source, Encoding encoding)
        {
            byte[] stringAsBytes = encoding.GetBytes(source);
            using (var memoryStream = new MemoryStream())
            {
                using (var zipStream = new GZipStream(memoryStream, CompressionMode.Compress))
                {
                    zipStream.Write(stringAsBytes, 0, stringAsBytes.Length);
                    zipStream.Close();
                    return (memoryStream.ToArray());
                }
            }
        }

        public static string DecompressGZip(byte[] source)
        {
            const int bufferSize = 1024;
            using (var memoryStream = new MemoryStream(source))
            {
                using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
                {
                    using (var outStream = new MemoryStream())
                    {
                        var buffer = new byte[bufferSize];
                        int totalBytes = 0;
                        int readBytes;
                        while ((readBytes = zipStream.Read(buffer, 0, bufferSize)) > 0)
                        {
                            outStream.Write(buffer, 0, readBytes);
                            totalBytes += readBytes;
                        }
                        return Encoding.Default.GetString(outStream.GetBuffer(), 0, totalBytes);
                    }
                }
            }
        }

        public static string DecompressGZip(byte[] source, Encoding encoding)
        {
            const int bufferSize = 1024;
            using (var memoryStream = new MemoryStream(source))
            {
                using (var zipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
                {
                    using (var outStream = new MemoryStream())
                    {
                        var buffer = new byte[bufferSize];
                        int totalBytes = 0;
                        int readBytes;
                        while ((readBytes = zipStream.Read(buffer, 0, bufferSize)) > 0)
                        {
                            outStream.Write(buffer, 0, readBytes);
                            totalBytes += readBytes;
                        }
                        return encoding.GetString(outStream.GetBuffer(), 0, totalBytes);
                    }
                }
            }
        }

        public static void CreateGZip(FileInfo source)
        {
            using (FileStream originalFileStream = source.OpenRead())
            {
                using (FileStream compressedFileStream = File.Create(source.FullName + ".gz"))
                {
                    using (var compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress))
                    {
                        originalFileStream.CopyTo(compressionStream);
                    }
                }
            }
        }

        public static void CreateGZip(FileInfo source, string destination)
        {
            using (FileStream originalFileStream = source.OpenRead())
            {
                using (FileStream compressedFileStream = File.Create(destination))
                {
                    using (var compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress))
                    {
                        originalFileStream.CopyTo(compressionStream);
                    }
                }
            }
        }

        public static void CreateGZip(FileInfo source, FileInfo destination)
        {
            using (FileStream originalFileStream = source.OpenRead())
            {
                using (FileStream compressedFileStream = File.Create(destination.FullName))
                {
                    using (var compressionStream = new GZipStream(compressedFileStream, CompressionMode.Compress))
                    {
                        originalFileStream.CopyTo(compressionStream);
                    }
                }
            }
        }

        public static void ExtractGZipToDirectory(FileInfo source)
        {
            using (FileStream originalFileStream = source.OpenRead())
            {
                string newFileName = Path.GetFileNameWithoutExtension(source.FullName);

                using (FileStream decompressedFileStream = File.Create(newFileName))
                {
                    using (var decompressionStream = new GZipStream(originalFileStream, CompressionMode.Decompress))
                    {
                        decompressionStream.CopyTo(decompressedFileStream);
                    }
                }
            }
        }

        public static void ExtractGZipToDirectory(FileInfo source, string destination)
        {
            using (FileStream originalFileStream = source.OpenRead())
            {
                using (FileStream compressedFileStream = File.Create(destination))
                {
                    using (var compressionStream = new GZipStream(compressedFileStream, CompressionMode.Decompress))
                    {
                        originalFileStream.CopyTo(compressionStream);
                    }
                }
            }
        }

        public static void ExtractGZipToDirectory(FileInfo source, FileInfo destination)
        {
            using (FileStream originalFileStream = source.OpenRead())
            {
                using (FileStream compressedFileStream = File.Create(destination.FullName))
                {
                    using (var compressionStream = new GZipStream(compressedFileStream, CompressionMode.Decompress))
                    {
                        originalFileStream.CopyTo(compressionStream);
                    }
                }
            }
        }

        public static void CreateZipFile(DirectoryInfo source, string destinationArchiveFileName)
        {
            ZipFile.CreateFromDirectory(source.FullName, destinationArchiveFileName);
        }

        public static void CreateZipFile(DirectoryInfo source, string destinationArchiveFileName, CompressionLevel compressionLevel, bool includeBaseDirectory)
        {
            ZipFile.CreateFromDirectory(source.FullName, destinationArchiveFileName, compressionLevel, includeBaseDirectory);
        }

        public static void CreateZipFile(DirectoryInfo source, string destinationArchiveFileName, CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding entryNameEncoding)
        {
            ZipFile.CreateFromDirectory(source.FullName, destinationArchiveFileName, compressionLevel, includeBaseDirectory, entryNameEncoding);
        }

        public static void CreateZipFile(DirectoryInfo source, FileInfo destinationArchiveFile)
        {
            ZipFile.CreateFromDirectory(source.FullName, destinationArchiveFile.FullName);
        }

        public static void CreateZipFile(DirectoryInfo source, FileInfo destinationArchiveFile, CompressionLevel compressionLevel, bool includeBaseDirectory)
        {
            ZipFile.CreateFromDirectory(source.FullName, destinationArchiveFile.FullName, compressionLevel, includeBaseDirectory);
        }

        public static void CreateZipFile(DirectoryInfo source, FileInfo destinationArchiveFile, CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding entryNameEncoding)
        {
            ZipFile.CreateFromDirectory(source.FullName, destinationArchiveFile.FullName, compressionLevel, includeBaseDirectory, entryNameEncoding);
        }

        public static void ExtractZipFileToDirectory(FileInfo source, string destinationDirectoryName)
        {
            ZipFile.ExtractToDirectory(source.FullName, destinationDirectoryName);
        }

        public static void ExtractZipFileToDirectory(FileInfo source, string destinationDirectoryName, Encoding entryNameEncoding)
        {
            ZipFile.ExtractToDirectory(source.FullName, destinationDirectoryName, entryNameEncoding);
        }

        public static void ExtractZipFileToDirectory(FileInfo source, DirectoryInfo destinationDirectory)
        {
            ZipFile.ExtractToDirectory(source.FullName, destinationDirectory.FullName);
        }

        public static void ExtractZipFileToDirectory(FileInfo source, DirectoryInfo destinationDirectory, Encoding entryNameEncoding)
        {
            ZipFile.ExtractToDirectory(source.FullName, destinationDirectory.FullName, entryNameEncoding);
        }

        public static ZipArchive OpenReadZipFile(string source)
        {
            return ZipFile.OpenRead(source);
        }

        public static ZipArchive OpenReadZipFile(FileInfo source)
        {
            return ZipFile.OpenRead(source.FullName);
        }

        public static ZipArchive OpenZipFile(FileInfo source, ZipArchiveMode mode)
        {
            return ZipFile.Open(source.FullName, mode);
        }

        public static ZipArchive OpenZipFile(FileInfo source, ZipArchiveMode mode, Encoding entryNameEncoding)
        {
            return ZipFile.Open(source.FullName, mode, entryNameEncoding);
        }

        public static void ExtractRarFileToDirectory(string sourceFile, string destDir)
        {
            System.Diagnostics.Process process = new System.Diagnostics.Process();
            process.StartInfo.FileName = GetRarExeFileName();
            process.StartInfo.CreateNoWindow = true;
            process.StartInfo.UseShellExecute = false;

            if (!Directory.Exists(destDir))
            {
                Directory.CreateDirectory(destDir);
            }

            process.StartInfo.Arguments = $" x -d -ep2 -ibck -o+ \"{sourceFile}\" \"{destDir}\"";
            process.Start();
            process.WaitForExit();
        }

        public static void CreateRarFile(string sourceDir, string destFileName)
        {
            System.Diagnostics.Process process = new System.Diagnostics.Process();
            process.StartInfo.FileName = GetRarExeFileName();
            process.StartInfo.CreateNoWindow = true;
            process.StartInfo.UseShellExecute = false;

            process.StartInfo.Arguments = $" a -r -ep1 -ibck \"{destFileName}\" \"{sourceDir}\"";
            process.Start();
            process.WaitForExit();
        }

        private static string GetRarExeFileName()
        {
            string rarFileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "rar", "rar.exe");
            if (!File.Exists(rarFileName))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(rarFileName));
                File.WriteAllBytes(rarFileName, Properties.Resources.rar);
            }
            return rarFileName;
        }
    }
}