FileStream stream = new FileStream(
    path: "data.bin",
    mode: FileMode.OpenOrCreate,
    access: FileAccess.ReadWrite,
    share: FileShare.None,
    bufferSize: 4096,
    useAsync: true
);

using System;
using System.IO;
using System.Text;

class FileStreamDemo
{
    static void Main()
    {
        string filePath = "message.bin";
        
        // ЗАПИС
        using (FileStream writeStream = new FileStream(
            filePath, 
            FileMode.Create, 
            FileAccess.Write))
        {
            string message = "Привіт, FileStream!";
            byte[] messageBytes = Encoding.UTF8.GetBytes(message);
            
            // Записуємо довжину повідомлення (4 байти)
            byte[] lengthBytes = BitConverter.GetBytes(messageBytes.Length);
            writeStream.Write(lengthBytes, 0, lengthBytes.Length);
            
            // Записуємо саме повідомлення
            writeStream.Write(messageBytes, 0, messageBytes.Length);
            
            Console.WriteLine($"Записано {messageBytes.Length} байт");
        } // using автоматично викликає Dispose() → Close()
        
        // ЧИТАННЯ
        using (FileStream readStream = new FileStream(
            filePath, 
            FileMode.Open, 
            FileAccess.Read))
        {
            // Читаємо довжину
            byte[] lengthBytes = new byte[4];
            readStream.Read(lengthBytes, 0, 4);
            int messageLength = BitConverter.ToInt32(lengthBytes, 0);
            
            // Читаємо повідомлення
            byte[] messageBytes = new byte[messageLength];
            readStream.Read(messageBytes, 0, messageLength);
            
            string message = Encoding.UTF8.GetString(messageBytes);
            Console.WriteLine($"Прочитано: {message}");
        }
    }
}

using System;
using System.IO;

class LargeFileReader
{
    static void Main()
    {
        string logPath = "huge_log.txt";
        
        // Створюємо демонстраційний файл (багато рядків)
        CreateDemoLog(logPath, lines: 1_000_000);
        
        Console.WriteLine("Пошук помилок у великому файлі...\n");
        
        int errorCount = 0;
        int chunkSize = 4096; // 4 KB
        byte[] buffer = new byte[chunkSize];
        
        using (FileStream fs = new FileStream(logPath, FileMode.Open, FileAccess.Read))
        {
            int bytesRead;
            long totalBytes = 0;
            
            // Читаємо файл частинами
            while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
            {
                totalBytes += bytesRead;
                
                // Конвертуємо chunk у рядок
                string chunk = System.Text.Encoding.UTF8.GetString(buffer, 0, bytesRead);
                
                // Рахуємо помилки
                errorCount += CountOccurrences(chunk, "ERROR");
                
                // Прогрес (кожні 10 MB)
                if (totalBytes % (10 * 1024 * 1024) == 0)
                {
                    Console.WriteLine($"Оброблено: {totalBytes / 1024 / 1024} MB");
                }
            }
        }
        
        Console.WriteLine($"\n✅ Знайдено помилок: {errorCount}");
        Console.WriteLine($"Розмір файлу: {new FileInfo(logPath).Length / 1024 / 1024} MB");
    }
    
    static void CreateDemoLog(string path, int lines)
    {
        using (StreamWriter writer = new StreamWriter(path))
        {
            var random = new Random();
            for (int i = 0; i < lines; i++)
            {
                string level = random.Next(10) == 0 ? "ERROR" : "INFO";
                writer.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} [{level}] Message #{i}");
            }
        }
    }
    
    static int CountOccurrences(string text, string substring)
    {
        int count = 0;
        int index = 0;
        while ((index = text.IndexOf(substring, index)) != -1)
        {
            count++;
            index += substring.Length;
        }
        return count;
    }
}

using System;
using System.IO;
using System.Text;

class MemoryStreamDemo
{
    static void Main()
    {
        // Створюємо пустий MemoryStream
        using (MemoryStream ms = new MemoryStream())
        {
            // Записуємо дані
            string message = "Дані у пам'яті";
            byte[] messageBytes = Encoding.UTF8.GetBytes(message);
            ms.Write(messageBytes, 0, messageBytes.Length);
            
            Console.WriteLine($"Позиція після запису: {ms.Position}");
            Console.WriteLine($"Довжина потоку: {ms.Length}");
            
            // Повертаємося на початок для читання
            ms.Position = 0;
            
            // Читаємо дані
            byte[] buffer = new byte[ms.Length];
            ms.Read(buffer, 0, buffer.Length);
            
            string readMessage = Encoding.UTF8.GetString(buffer);
            Console.WriteLine($"Прочитано: {readMessage}");
            
            // Отримуємо масив байтів
            byte[] allData = ms.ToArray();
            Console.WriteLine($"ToArray() повернув {allData.Length} байт");
        }
        
        // Створюємо MemoryStream з існуючого масиву
        byte[] existingData = Encoding.UTF8.GetBytes("Попередні дані");
        using (MemoryStream ms2 = new MemoryStream(existingData))
        {
            ms2.Position = ms2.Length; // Переходимо в кінець
            
            // Додаємо нові дані
            byte[] newData = Encoding.UTF8.GetBytes(" + нові дані");
            ms2.Write(newData, 0, newData.Length);
            
            ms2.Position = 0; // Повертаємося на початок
            byte[] combined = ms2.ToArray();
            Console.WriteLine($"\nОб'єднані дані: {Encoding.UTF8.GetString(combined)}");
        }
    }
}

using System;
using System.IO;

class StreamReaderDemo
{
    static void Main()
    {
        string filePath = "diary.txt";
        
        // Створюємо демонстраційний файл
        File.WriteAllLines(filePath, new[]
        {
            "2026-01-10: Вивчаю C# Streams",
            "2026-01-11: Практикую async I/O",
            "2026-01-12: Будую реальний проєкт"
        });
        
        // Читання всього файлу
        using (StreamReader reader = new StreamReader(filePath))
        {
            string content = reader.ReadToEnd();
            Console.WriteLine("=== ВЕСЬ ВМІСТ ===");
            Console.WriteLine(content);
        }
        
        // Читання по рядках
        Console.WriteLine("\n=== ПОРЯДКОВЕ ЧИТАННЯ ===");
        using (StreamReader reader = new StreamReader(filePath))
        {
            string line;
            int lineNumber = 1;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine($"[{lineNumber}] {line}");
                lineNumber++;
            }
        }
        
        // Читання з кодуванням
        using (StreamReader reader = new StreamReader(filePath, System.Text.Encoding.UTF8))
        {
            Console.WriteLine($"\nПерший символ: '{(char)reader.Read()}'");
        }
    }
}

using System;
using System.IO;

class StreamWriterDemo
{
    static void Main()
    {
        string logPath = "application.log";
        
        // Запис з перезаписом
        using (StreamWriter writer = new StreamWriter(logPath))
        {
            writer.WriteLine($"[{DateTime.Now}] Application started");
            writer.WriteLine($"[{DateTime.Now}] Initializing components...");
            writer.Write("Progress: ");
            writer.Write("25%... ");
            writer.WriteLine("50%... Done!");
        }
        
        // Додавання до існуючого файлу
        using (StreamWriter writer = new StreamWriter(logPath, append: true))
        {
            writer.WriteLine($"[{DateTime.Now}] New log entry");
        }
        
        // Запис з кодуванням та буферизацією
        using (StreamWriter writer = new StreamWriter(
            path: logPath,
            append: true,
            encoding: System.Text.Encoding.UTF8,
            bufferSize: 65536)) // 64 KB buffer
        {
            for (int i = 0; i < 1000; i++)
            {
                writer.WriteLine($"[{DateTime.Now}] Iteration {i}");
            }
            // writer.Flush(); // Примусово скинути буфер (викликається автоматично при Dispose)
        }
        
        // Виводимо результат
        Console.WriteLine("=== ЛОГ ФАЙЛ ===");
        Console.WriteLine(File.ReadAllText(logPath));
    }
}

using System;
using System.IO;

// Модель даних
record PlayerData(string Name, int Level, float Health, bool IsOnline);

class BinaryDataDemo
{
    static void Main()
    {
        string savePath = "player_save.dat";
        
        // Створюємо дані гравця
        var player = new PlayerData("Aragorn", 42, 95.5f, true);
        
        // ЗАПИС у бінарний файл
        using (FileStream fs = new FileStream(savePath, FileMode.Create))
        using (BinaryWriter writer = new BinaryWriter(fs))
        {
            writer.Write(player.Name);    // string
            writer.Write(player.Level);   // int (4 bytes)
            writer.Write(player.Health);  // float (4 bytes)
            writer.Write(player.IsOnline);// bool (1 byte)
            
            Console.WriteLine("Дані збережено!");
        }
        
        // ЧИТАННЯ з бінарного файлу
        using (FileStream fs = new FileStream(savePath, FileMode.Open))
        using (BinaryReader reader = new BinaryReader(fs))
        {
            string name = reader.ReadString();
            int level = reader.ReadInt32();
            float health = reader.ReadSingle();
            bool isOnline = reader.ReadBoolean();
            
            var loadedPlayer = new PlayerData(name, level, health, isOnline);
            
            Console.WriteLine($"\nДані завантажено:");
            Console.WriteLine($"  Ім'я: {loadedPlayer.Name}");
            Console.WriteLine($"  Рівень: {loadedPlayer.Level}");
            Console.WriteLine($"  Здоров'я: {loadedPlayer.Health}");
            Console.WriteLine($"  Онлайн: {loadedPlayer.IsOnline}");
        }
        
        // Перевіряємо розмір файлу
        FileInfo fileInfo = new FileInfo(savePath);
        Console.WriteLine($"\nРозмір файлу: {fileInfo.Length} байт");
    }
}

using System;
using System.IO;
using System.IO.Compression;

class GZipDemo
{
    static void Main()
    {
        string sourceFile = "large_document.txt";
        string compressedFile = "large_document.txt.gz";
        string decompressedFile = "large_document_restored.txt";
        
        // Створюємо великий файл для демонстрації
        File.WriteAllText(sourceFile, new string('A', 1_000_000)); // 1 MB букв 'A'
        
        // СТИСНЕННЯ
        Console.WriteLine("Стискання...");
        using (FileStream sourceStream = new FileStream(sourceFile, FileMode.Open))
        using (FileStream compressedStream = new FileStream(compressedFile, FileMode.Create))
        using (GZipStream gzipStream = new GZipStream(compressedStream, CompressionMode.Compress))
        {
            sourceStream.CopyTo(gzipStream);
        }
        
        // РОЗПАКУВАННЯ
        Console.WriteLine("Розпакування...");
        using (FileStream compressedStream = new FileStream(compressedFile, FileMode.Open))
        using (GZipStream gzipStream = new GZipStream(compressedStream, CompressionMode.Decompress))
        using (FileStream decompressedStream = new FileStream(decompressedFile, FileMode.Create))
        {
            gzipStream.CopyTo(decompressedStream);
        }
        
        // Порівняння розмірів
        long originalSize = new FileInfo(sourceFile).Length;
        long compressedSize = new FileInfo(compressedFile).Length;
        long restoredSize = new FileInfo(decompressedFile).Length;
        
        Console.WriteLine($"\nРозміри:");
        Console.WriteLine($"  Оригінал:      {originalSize:N0} байт");
        Console.WriteLine($"  Стиснутий:     {compressedSize:N0} байт");
        Console.WriteLine($"  Відновлений:   {restoredSize:N0} байт");
        Console.WriteLine($"  Коефіцієнт:    {(double)compressedSize / originalSize:P2}");
        
        // Перевірка коректності
        string originalContent = File.ReadAllText(sourceFile);
        string restoredContent = File.ReadAllText(decompressedFile);
        Console.WriteLine($"\nДані ідентичні: {originalContent == restoredContent}");
    }
}

using System;
using System.IO;
using System.IO.Compression;

class ZipArchiveDemo
{
    static void Main()
    {
        string archivePath = "backup.zip";
        
        // Створюємо демонстраційні файли
        Directory.CreateDirectory("TempData");
        File.WriteAllText("TempData/file1.txt", "Вміст файлу 1");
        File.WriteAllText("TempData/file2.txt", "Вміст файлу 2");
        File.WriteAllText("TempData/file3.txt", "Вміст файлу 3");
        
        // СТВОРЕННЯ ZIP-АРХІВУ
        Console.WriteLine("Створення архіву...");
        using (FileStream zipToOpen = new FileStream(archivePath, FileMode.Create))
        using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Create))
        {
            // Додаємо файли
            foreach (string filePath in Directory.GetFiles("TempData"))
            {
                string entryName = Path.GetFileName(filePath);
                ZipArchiveEntry entry = archive.CreateEntry(entryName, CompressionLevel.Optimal);
                
                using (Stream entryStream = entry.Open())
                using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
                {
                    fileStream.CopyTo(entryStream);
                }
                
                Console.WriteLine($"  Додано: {entryName}");
            }
        }
        
        // ЧИТАННЯ ZIP-АРХІВУ
        Console.WriteLine("\n=== ВМІСТ АРХІВУ ===");
        using (FileStream zipToOpen = new FileStream(archivePath, FileMode.Open))
        using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Read))
        {
            foreach (ZipArchiveEntry entry in archive.Entries)
            {
                Console.WriteLine($"📄 {entry.Name} ({entry.CompressedLength} / {entry.Length} байт)");
            }
        }
        
        // РОЗПАКУВАННЯ
        Console.WriteLine("\nРозпакування...");
        ZipFile.ExtractToDirectory(archivePath, "ExtractedData", overwriteFiles: true);
        
        Console.WriteLine("✅ Архів створено та розпаковано!");
    }
}

using System;
using System.IO;
using System.Threading.Tasks;
using System.Diagnostics;

class AsyncIODemo
{
    static async Task Main()
    {
        string sourceFile = "large_video.mp4";
        string destFile = "large_video_copy.mp4";
        
        // Створюємо великий файл (100 MB) для демонстрації
        Console.WriteLine("Створення демонстраційного файлу...");
        await CreateLargeFileAsync(sourceFile, sizeInMB: 100);
        
        // Синхронне копіювання
        Console.WriteLine("\n[SYNC] Копіювання...");
        Stopwatch sw = Stopwatch.StartNew();
        File.Copy(sourceFile, destFile, overwrite: true);
        sw.Stop();
        Console.WriteLine($"Час: {sw.ElapsedMilliseconds} мс");
        File.Delete(destFile);
        
        // Асинхронне копіювання
        Console.WriteLine("\n[ASYNC] Копіювання...");
        sw.Restart();
        await CopyFileAsync(sourceFile, destFile);
        sw.Stop();
        Console.WriteLine($"Час: {sw.ElapsedMilliseconds} мс");
        
        Console.WriteLine("\n✅ Завершено!");
    }
    
    static async Task CopyFileAsync(string sourcePath, string destPath)
    {
        const int bufferSize = 81920; // 80 KB
        
        using (FileStream sourceStream = new FileStream(
            sourcePath, 
            FileMode.Open, 
            FileAccess.Read, 
            FileShare.Read, 
            bufferSize, 
            useAsync: true)) // Критично важливо!
        using (FileStream destStream = new FileStream(
            destPath, 
            FileMode.Create, 
            FileAccess.Write, 
            FileShare.None, 
            bufferSize, 
            useAsync: true))
        {
            await sourceStream.CopyToAsync(destStream);
        }
    }
    
    static async Task CreateLargeFileAsync(string path, int sizeInMB)
    {
        byte[] buffer = new byte[1024 * 1024]; // 1 MB buffer
        new Random().NextBytes(buffer); // Випадкові дані
        
        using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None, buffer.Length, useAsync: true))
        {
            for (int i = 0; i < sizeInMB; i++)
            {
                await fs.WriteAsync(buffer, 0, buffer.Length);
            }
        }
    }
}