#include <fstream>  // ifstream, ofstream, fstream
// Додатково може знадобитися:
#include <string>   // std::string, std::getline
#include <sstream>  // std::istringstream, std::ostringstream

#include <fstream>
#include <string>

int main()
{
    std::ofstream outputFile("notes.txt");

    // Перевірка відкриття (метод is_open або неявне перетворення до bool)
    if (!outputFile)
    {
        return 1;
    }

    // Запис різних типів — синтаксис ідентичний cout
    outputFile << "Ім\'я: " << "Іван Петренко" << "\n";
    outputFile << "Вік: "   << 20               << "\n";
    outputFile << "GPA: "   << 4.75             << "\n";
    outputFile << "Активний: " << true          << "\n";

    // Файл закривається автоматично при виході зі scope (RAII)
    return 0;
}

#include <fstream>
#include <iostream>

int main()
{
    std::ofstream file("data.txt");

    if (!file.is_open())
    {
        std::cerr << "Помилка відкриття файлу\n";
        return 1;
    }

    file << "Hello, file!\n";

    // Явно закриваємо — RAII все одно спрацює при виході,
    // але явний close() дозволяє перевірити помилку запису
    file.close();

    if (file.fail())
    {
        std::cerr << "Помилка під час закриття файлу\n";
        return 1;
    }

    std::cout << "Файл успішно записано і закрито\n";
    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

int main()
{
    // Спочатку запишемо тестовий файл
    {
        std::ofstream outFile("numbers.txt");
        outFile << "10 25 37 42 58\n";
    }

    // Відкриваємо для читання
    std::ifstream inputFile("numbers.txt");

    if (!inputFile.is_open())
    {
        std::cerr << "Файл не знайдено\n";
        return 1;
    }

    int value;
    int sum   = 0;
    int count = 0;

    // Читання у циклі — оператор >> повертає потік,
    // який неявно перетворюється до bool (false при EOF або помилці)
    while (inputFile >> value)
    {
        std::cout << "Прочитано: " << value << "\n";
        sum   += value;
        count++;
    }

    std::cout << "Сума: " << sum << ", Кількість: " << count << "\n";
    std::cout << "Середнє: " << static_cast<double>(sum) / count << "\n";

    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

int main()
{
    // Записуємо тестовий файл з реченнями
    {
        std::ofstream outFile("poem.txt");
        outFile << "Реве та стогне Дніпр широкий,\n";
        outFile << "Сердитий вітер завива,\n";
        outFile << "Додолу верби гне високі,\n";
        outFile << "Горами хвилю підійма.\n";
    }

    std::ifstream inputFile("poem.txt");
    if (!inputFile.is_open())
    {
        std::cerr << "Файл не знайдено\n";
        return 1;
    }

    std::string line;
    int         lineNum = 0;

    while (std::getline(inputFile, line))
    {
        lineNum++;
        std::cout << lineNum << ": " << line << "\n";
    }

    std::cout << "\nВсього рядків: " << lineNum << "\n";

    return 0;
}

#include <fstream>
#include <iostream>

int main()
{
    // Перший запуск: створюємо файл
    {
        std::ofstream logFile("app.log");
        logFile << "[2024-01-01] Програма запущена\n";
    }

    // Другий запуск: ДОЗАПИСУЄМО, не перезаписуємо
    {
        std::ofstream logFile("app.log", std::ios::app);
        logFile << "[2024-01-01] Операція виконана\n";
        logFile << "[2024-01-01] Програма завершена\n";
    }

    // Читаємо весь файл
    std::ifstream inFile("app.log");
    std::string   line;
    while (std::getline(inFile, line))
    {
        std::cout << line << "\n";
    }

    return 0;
}

#include <fstream>
#include <iostream>

int main()
{
    // Спочатку створюємо файл
    {
        std::ofstream outFile("data.txt");
        outFile << "Hello World\n";
        outFile << "C++ Files\n";
    }

    // Відкриваємо для читання і запису
    std::fstream rwFile("data.txt", std::ios::in | std::ios::out);

    if (!rwFile.is_open())
    {
        std::cerr << "Файл не знайдено\n";
        return 1;
    }

    // Читаємо перший рядок
    std::string firstLine;
    std::getline(rwFile, firstLine);
    std::cout << "Перший рядок: " << firstLine << "\n";

    // Файловий покажчик тепер після першого рядка
    // Записуємо в поточну позицію
    rwFile << "INSERTED LINE\n";

    // Перечитуємо весь файл
    rwFile.seekg(0);
    std::string line;
    std::cout << "\nВміст після модифікації:\n";
    while (std::getline(rwFile, line))
    {
        std::cout << line << "\n";
    }

    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

int main()
{
    std::ifstream inputFile;  // Поки не відкритий

    std::string fileName;
    std::cout << "Введіть ім'я файлу: ";
    std::cin >> fileName;

    // Відкриваємо пізніше
    inputFile.open(fileName);

    if (!inputFile.is_open())
    {
        std::cerr << "Файл '" << fileName << "' не знайдено\n";
        return 1;
    }

    std::string line;
    int         lineCount = 0;

    while (std::getline(inputFile, line))
    {
        lineCount++;
    }

    inputFile.close();  // Явно закриваємо

    std::cout << "Рядків у файлі: " << lineCount << "\n";

    // Повторно відкриваємо той самий об'єкт
    inputFile.open(fileName);
    if (inputFile.is_open())
    {
        std::cout << "Перший рядок: ";
        std::getline(inputFile, line);
        std::cout << line << "\n";
    }

    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

int main()
{
    // Підготуємо файл з числами і рядком
    {
        std::ofstream outFile("mixed.txt");
        outFile << "42 17 hello 99\n";
    }

    std::ifstream inFile("mixed.txt");
    int           value;

    // Читаємо числа, поки не помилка (рядок "hello" не є int)
    while (inFile >> value)
    {
        std::cout << "Прочитано: " << value << "\n";
    }

    // Аналізуємо стан
    std::cout << "\nСтан після читання:\n";
    std::cout << "  good(): " << inFile.good() << "\n";
    std::cout << "  eof():  " << inFile.eof()  << "\n";
    std::cout << "  fail(): " << inFile.fail() << "\n";
    std::cout << "  bad():  " << inFile.bad()  << "\n";

    // Скидаємо failbit — це дозволяє читати далі
    inFile.clear();

    // Читаємо невдале слово як рядок
    std::string word;
    inFile >> word;
    std::cout << "\nНевдале слово було: \"" << word << "\"\n";

    // Продовжуємо читання числа
    inFile >> value;
    std::cout << "Наступне число: " << value << "\n";

    return 0;
}

#include <fstream>
#include <iostream>
#include <stdexcept>

int main()
{
    std::ifstream inFile;

    // Налаштовуємо: кидати виключення при failbit і badbit
    inFile.exceptions(std::ios::failbit | std::ios::badbit);

    try
    {
        inFile.open("nonexistent.txt");

        // До цього рядка ми не дійдемо — open() кине виключення
        std::string line;
        std::getline(inFile, line);
    }
    catch (const std::ios_base::failure& e)
    {
        std::cerr << "Помилка файлового потоку: " << e.what() << "\n";
    }

    return 0;
}

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

struct Student
{
    std::string name;
    int         age;
    double      gpa;
};

// Записати вектор студентів у файл (формат CSV)
void saveStudents(const std::string& filename, const std::vector<Student>& students)
{
    std::ofstream outFile(filename);

    if (!outFile.is_open())
    {
        std::cerr << "Помилка: не вдалося відкрити файл для запису\n";
        return;
    }

    for (const auto& s : students)
    {
        // Формат: ім'я,вік,gpa
        outFile << s.name << "," << s.age << "," << s.gpa << "\n";
    }
}

// Зчитати студентів з CSV-файлу
std::vector<Student> loadStudents(const std::string& filename)
{
    std::vector<Student> result;
    std::ifstream        inFile(filename);

    if (!inFile.is_open())
    {
        std::cerr << "Помилка: файл не знайдено\n";
        return result;
    }

    std::string line;
    while (std::getline(inFile, line))
    {
        Student s;

        // Парсимо CSV-рядок через stringstream
        std::istringstream ss(line);
        std::string        ageStr;
        std::string        gpaStr;

        std::getline(ss, s.name,   ',');
        std::getline(ss, ageStr,   ',');
        std::getline(ss, gpaStr,   ',');

        s.age = std::stoi(ageStr);
        s.gpa = std::stod(gpaStr);

        result.push_back(s);
    }

    return result;
}

int main()
{
    std::vector<Student> students = {
        { "Іван Петренко",   20, 4.5 },
        { "Олена Коваль",    19, 4.8 },
        { "Михайло Бойко",   21, 3.9 },
        { "Анна Савченко",   20, 4.2 }
    };

    const std::string fileName = "students.csv";
    saveStudents(fileName, students);
    std::cout << "Збережено " << students.size() << " студентів у " << fileName << "\n";

    auto loaded = loadStudents(fileName);
    std::cout << "\nЗавантажено " << loaded.size() << " студентів:\n";

    for (const auto& s : loaded)
    {
        std::cout << "  " << s.name
                  << " | вік: " << s.age
                  << " | GPA: " << s.gpa << "\n";
    }

    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

class Logger
{
public:
    explicit Logger(const std::string& filename)
        : m_file(filename, std::ios::app)
    {
        if (!m_file.is_open())
        {
            throw std::runtime_error("Не вдалося відкрити лог-файл: " + filename);
        }
    }

    void log(const std::string& message)
    {
        m_file << message << "\n";
        m_file.flush();  // Гарантуємо запис на диск
    }

    // Деструктор автоматично закриє файл (RAII)

private:
    std::ofstream m_file;
};

int main()
{
    Logger logger("system.log");

    logger.log("[INFO] Програма запущена");
    logger.log("[INFO] Ініціалізація завершена");
    logger.log("[WARN] Низький рівень пам'яті");
    logger.log("[INFO] Програма завершена");

    std::cout << "Записи успішно збережено у system.log\n";
    return 0;
}

#include <fstream>
#include <iostream>

std::streamsize getFileSize(const std::string& filename)
{
    std::ifstream file(filename, std::ios::binary | std::ios::ate);

    if (!file.is_open())
    {
        return -1;
    }

    // ios::ate вже перемістив покажчик у кінець
    // tellg() повертає поточну позицію = розмір файлу
    return file.tellg();
}

int main()
{
    std::streamsize size = getFileSize("students.csv");

    if (size == -1)
    {
        std::cerr << "Файл не знайдено\n";
        return 1;
    }

    std::cout << "Розмір students.csv: " << size << " байтів\n";
    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

std::string readFileToString(const std::string& filename)
{
    std::ifstream file(filename, std::ios::binary);

    if (!file.is_open())
    {
        return "";
    }

    // Визначаємо розмір
    file.seekg(0, std::ios::end);
    std::streamsize fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    // Читаємо весь файл одним блоком
    std::string content(static_cast<size_t>(fileSize), '\0');
    file.read(content.data(), fileSize);

    return content;
}

int main()
{
    std::string text = readFileToString("poem.txt");

    if (text.empty())
    {
        std::cerr << "Файл не знайдено або порожній\n";
        return 1;
    }

    std::cout << "=== Вміст файлу ===\n" << text;
    std::cout << "=== Розмір: " << text.size() << " байтів ===\n";

    return 0;
}

#include <fstream>
#include <iostream>

int main()
{
    const int COUNT = 5;
    int writeData[COUNT] = { 100, 200, 300, 400, 500 };

    // --- Запис ---
    {
        std::ofstream outFile("numbers.bin", std::ios::binary);

        if (!outFile.is_open())
        {
            std::cerr << "Помилка запису\n";
            return 1;
        }

        // Записуємо весь масив одним блоком
        outFile.write(reinterpret_cast<const char*>(writeData),
                      COUNT * sizeof(int));
    }

    // --- Читання ---
    int readData[COUNT] = {};
    {
        std::ifstream inFile("numbers.bin", std::ios::binary);

        if (!inFile.is_open())
        {
            std::cerr << "Помилка читання\n";
            return 1;
        }

        inFile.read(reinterpret_cast<char*>(readData),
                    COUNT * sizeof(int));

        // Перевіряємо, скільки байтів реально прочитано
        std::streamsize bytesRead = inFile.gcount();
        std::cout << "Прочитано байтів: " << bytesRead << "\n";
    }

    // Виводимо прочитані дані
    std::cout << "Числа: ";
    for (int i = 0; i < COUNT; i++)
    {
        std::cout << readData[i] << " ";
    }
    std::cout << "\n";

    return 0;
}

#include <fstream>
#include <iostream>
#include <cstring>

struct StudentRecord
{
    char   name[50];
    int    age;
    double gpa;
};

int main()
{
    StudentRecord writeRecords[3];

    std::strncpy(writeRecords[0].name, "Petrenko Ivan",  49);
    writeRecords[0].age = 20;  writeRecords[0].gpa = 4.5;

    std::strncpy(writeRecords[1].name, "Koval Olena",   49);
    writeRecords[1].age = 19;  writeRecords[1].gpa = 4.8;

    std::strncpy(writeRecords[2].name, "Boiko Mykhailo", 49);
    writeRecords[2].age = 21;  writeRecords[2].gpa = 3.9;

    // --- Запис ---
    {
        std::ofstream outFile("students.bin", std::ios::binary);
        outFile.write(reinterpret_cast<const char*>(writeRecords),
                      3 * sizeof(StudentRecord));
    }

    // --- Читання одного запису за індексом ---
    std::ifstream inFile("students.bin", std::ios::binary);

    int         targetIndex = 1;
    StudentRecord record;

    // Переходимо до потрібного запису
    inFile.seekg(targetIndex * sizeof(StudentRecord));

    inFile.read(reinterpret_cast<char*>(&record), sizeof(StudentRecord));

    if (inFile.gcount() == sizeof(StudentRecord))
    {
        std::cout << "Запис [" << targetIndex << "]: "
                  << record.name
                  << " | вік: " << record.age
                  << " | GPA: " << record.gpa << "\n";
    }

    return 0;
}

#include <fstream>
#include <iostream>
#include <cctype>

bool isVowel(char ch)
{
    ch = std::tolower(ch);
    return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' || ch == 'y';
}

int main()
{
    // Створюємо тестовий файл
    {
        std::ofstream out("vowels.txt");
        out << "Hello, stream files in C++!\n";
    }

    // Відкриваємо для читання та запису
    std::fstream file("vowels.txt", std::ios::in | std::ios::out);

    if (!file.is_open())
    {
        std::cerr << "Помилка відкриття файлу\n";
        return 1;
    }

    char ch;
    // Читаємо символ за символом
    while (file.get(ch))
    {
        if (isVowel(ch))
        {
            // Отримуємо поточну позицію читання (вона змістилася на +1 після get)
            std::streampos pos = file.tellg();

            // Переходимо назад до символу, який щойно прочитали
            file.seekp(pos - std::streamoff(1));

            // Записуємо заміну
            file.put('#');

            // КРИТИЧНО: повертаємося назад на ту саму позицію читання,
            // щоб синхронізувати потоки та продовжити цикл get()
            file.seekg(pos);
        }
    }

    file.close();
    std::cout << "Голосні літери успішно замінено\n";
    return 0;
}

#include <fstream>
#include <iostream>
#include <string>

struct BadRecord
{
    int         id;
    std::string message; // Містить прихований покажчик на купу!
};

int main()
{
    BadRecord record1 = { 1, "Критично важливе повідомлення" };

    // Записуємо сирі байти структури
    std::ofstream out("bad.bin", std::ios::binary);
    out.write(reinterpret_cast<const char*>(&record1), sizeof(BadRecord));
    out.close();

    // Читаємо назад в іншому контексті
    BadRecord record2;
    std::ifstream in("bad.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(&record2), sizeof(BadRecord));
    in.close();

    // !!! Спроба виведення призведе до падіння програми (Crash) !!!
    // Тому що record2.message містить адресу пам'яті з попереднього запуску,
    // яка тепер є недійсною.
    // std::cout << record2.message << "\n";

    return 0;
}

#include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main()
{
    fs::path p("/Users/user/documents/report.pdf");

    std::cout << "Повний шлях:   " << p << "\n";
    std::cout << "Батьківська папка: " << p.parent_path() << "\n";
    std::cout << "Ім'я файлу:    " << p.filename() << "\n";
    std::cout << "Власне назва:  " << p.stem() << "\n";
    std::cout << "Розширення:    " << p.extension() << "\n";

    if (p.is_absolute())
    {
        std::cout << "Шлях є абсолютним\n";
    }

    return 0;
}

#include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main()
{
    fs::path targetDir = "."; // Поточна директорія

    std::cout << "Список файлів у папці " << fs::absolute(targetDir) << ":\n\n";

    try
    {
        // directory_iterator обходить елементи папки (без рекурсії)
        // Для рекурсивного обходу є recursive_directory_iterator
        for (const auto& entry : fs::directory_iterator(targetDir))
        {
            const auto& path = entry.path();
            
            if (fs::is_directory(path))
            {
                std::cout << "[DIR]  " << path.filename().string() << "\n";
            }
            else if (fs::is_regular_file(path))
            {
                std::cout << "[FILE] " << path.filename().string() 
                          << " (" << fs::file_size(path) << " байтів)\n";
            }
        }
    }
    catch (const fs::filesystem_error& e)
    {
        std::cerr << "Помилка файлової системи: " << e.what() << "\n";
    }

    return 0;
}

#include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main()
{
    fs::path newDir = "test_sandbox";
    fs::path file1  = newDir / "note.txt"; // Оператор / з'єднує шляхи
    fs::path file2  = newDir / "backup.txt";

    // 1. Створення папки
    if (fs::create_directory(newDir))
    {
        std::cout << "Створено папку: " << newDir << "\n";
    }

    // Створимо файл для тестування
    std::ofstream(file1) << "Hello, filesystem!\n";

    // 2. Перевірка існування
    if (fs::exists(file1))
    {
        std::cout << "Файл " << file1.filename() << " існує\n";
    }

    // 3. Копіювання файлу
    fs::copy_file(file1, file2, fs::copy_options::overwrite_existing);
    std::cout << "Файл скопійовано\n";

    // 4. Перейменування/переміщення
    fs::path movedFile = newDir / "renamed_note.txt";
    fs::rename(file1, movedFile);
    std::cout << "Файл перейменовано\n";

    // 5. Видалення файлу або папки
    fs::remove(file2);      // видаляє один файл
    fs::remove_all(newDir); // рекурсивно видаляє папку з усім вмістом
    std::cout << "Очищення завершено, пісочницю видалено\n";

    return 0;
}