public class Book
{
    public string Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }

    public void SaveToFile(string filename)
    {
        // Логіка серіалізації в JSON
        // Запис у файл
    }

    public static Book LoadFromFile(string filename, string id)
    {
        // Читання з файлу
        // Десеріалізація з JSON
        return book;
    }
}

namespace Library.Domain;

/// <summary>
/// Доменна модель книги.
/// Цей клас повністю ізольований від логіки персистентності.
/// </summary>
public class Book
{
    public string Id { get; private set; }
    public string Title { get; set; }
    public string Author { get; set; }
    public int Year { get; set; }
    public string Isbn { get; set; }
    public bool IsAvailable { get; private set; }

    // Конструктор для створення нової книги
    public Book(string title, string author, int year, string isbn)
    {
        Id = Guid.NewGuid().ToString();
        Title = title;
        Author = author;
        Year = year;
        Isbn = isbn;
        IsAvailable = true;
    }

    // Конструктор для відновлення з персистентного сховища (для десеріалізації)
    public Book(string id, string title, string author, int year, string isbn, bool isAvailable)
    {
        Id = id;
        Title = title;
        Author = author;
        Year = year;
        Isbn = isbn;
        IsAvailable = isAvailable;
    }

    // Приватний конструктор для JSON-десеріалізації
    private Book() { }

    // Бізнес-логіка
    public void Borrow()
    {
        if (!IsAvailable)
        {
            throw new InvalidOperationException("Книга вже видана");
        }
        IsAvailable = false;
    }

    public void Return()
    {
        if (IsAvailable)
        {
            throw new InvalidOperationException("Книга не була видана");
        }
        IsAvailable = true;
    }

    public override bool Equals(object? obj)
    {
        if (obj is not Book other) return false;
        return Id == other.Id;
    }

    public override int GetHashCode() => Id.GetHashCode();

    public override string ToString()
    {
        return $"Book {{ Id = {Id}, Title = {Title}, Author = {Author}, Year = {Year}, Available = {IsAvailable} }}";
    }
}

using System.Text.Json;
using Library.Domain;

namespace Library.Persistence;

/// <summary>
/// Простий Data Mapper для роботи з книгами.
/// Відповідає за перетворення між доменними об'єктами та JSON.
/// </summary>
public class BookMapper
{
    private readonly string _filePath;
    private readonly JsonSerializerOptions _jsonOptions;

    public BookMapper(string filename)
    {
        _filePath = filename;
        _jsonOptions = new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            PropertyNameCaseInsensitive = true
        };
        
        EnsureDirectoryExists();
    }

    private void EnsureDirectoryExists()
    {
        var directory = Path.GetDirectoryName(_filePath);
        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
        {
            Directory.CreateDirectory(directory);
        }
    }

    /// <summary>
    /// Зберігає книгу у файл.
    /// Якщо книга з таким Id вже існує — оновлює її.
    /// </summary>
    public void Save(Book book)
    {
        var books = FindAll();

        // Шукаємо існуючу книгу за Id
        var existingIndex = books.FindIndex(b => b.Id == book.Id);
        
        if (existingIndex >= 0)
        {
            books[existingIndex] = book;
        }
        else
        {
            books.Add(book);
        }

        WriteToFile(books);
    }

    /// <summary>
    /// Знаходить книгу за її ідентифікатором.
    /// </summary>
    public Book? FindById(string id)
    {
        return FindAll().FirstOrDefault(book => book.Id == id);
    }

    /// <summary>
    /// Повертає всі книги зі сховища.
    /// </summary>
    public List<Book> FindAll()
    {
        if (!File.Exists(_filePath))
        {
            return new List<Book>();
        }

        var json = File.ReadAllText(_filePath);
        
        if (string.IsNullOrWhiteSpace(json))
        {
            return new List<Book>();
        }
        
        return JsonSerializer.Deserialize<List<Book>>(json, _jsonOptions) 
               ?? new List<Book>();
    }

    /// <summary>
    /// Видаляє книгу за ідентифікатором.
    /// </summary>
    public bool Delete(string id)
    {
        var books = FindAll();
        var removed = books.RemoveAll(book => book.Id == id) > 0;
        
        if (removed)
        {
            WriteToFile(books);
        }
        
        return removed;
    }

    /// <summary>
    /// Записує список книг у файл.
    /// </summary>
    private void WriteToFile(List<Book> books)
    {
        var json = JsonSerializer.Serialize(books, _jsonOptions);
        File.WriteAllText(_filePath, json);
    }
}

using Library.Domain;
using Library.Persistence;

// Створюємо маппер з вказівкою файлу для зберігання
var bookMapper = new BookMapper("data/books.json");

// Створюємо нові книги (доменні об'єкти)
var book1 = new Book(
    "Чистий код",
    "Роберт Мартін",
    2008,
    "978-0132350884"
);

var book2 = new Book(
    "Патерни проєктування",
    "Банда чотирьох",
    1994,
    "978-0201633610"
);

// Зберігаємо книги через маппер
bookMapper.Save(book1);
bookMapper.Save(book2);
Console.WriteLine("Книги збережено!");

// Читаємо всі книги
var allBooks = bookMapper.FindAll();
Console.WriteLine("\nВсі книги:");
foreach (var book in allBooks)
{
    Console.WriteLine(book);
}

// Знаходимо конкретну книгу
var foundBook = bookMapper.FindById(book1.Id);
if (foundBook != null)
{
    Console.WriteLine($"\nЗнайдена книга: {foundBook.Title}");

    // Виконуємо бізнес-логіку
    foundBook.Borrow();
    Console.WriteLine($"Книга видана, доступність: {foundBook.IsAvailable}");

    // Зберігаємо оновлений стан
    bookMapper.Save(foundBook);
}

// Перевіряємо оновлення
Console.WriteLine("\nПісля оновлення:");
foreach (var book in bookMapper.FindAll())
{
    Console.WriteLine(book);
}

using Library.Domain;

namespace Library.Tests;

public class BookTests
{
    [Fact]
    public void Borrow_ShouldChangeAvailability_WhenBookIsAvailable()
    {
        // Arrange
        var book = new Book("Test Book", "Author", 2024, "ISBN");
        Assert.True(book.IsAvailable);

        // Act
        book.Borrow();

        // Assert
        Assert.False(book.IsAvailable);
    }

    [Fact]
    public void Borrow_ShouldThrowException_WhenBookIsAlreadyBorrowed()
    {
        // Arrange
        var book = new Book("Test Book", "Author", 2024, "ISBN");
        book.Borrow(); // Перша видача

        // Act & Assert
        Assert.Throws<InvalidOperationException>(() => book.Borrow());
    }

    [Fact]
    public void Return_ShouldRestoreAvailability_WhenBookIsBorrowed()
    {
        // Arrange
        var book = new Book("Test Book", "Author", 2024, "ISBN");
        book.Borrow();

        // Act
        book.Return();

        // Assert
        Assert.True(book.IsAvailable);
    }
}

// Поточна реалізація
var jsonMapper = new BookMapper("books.json");

// Можлива майбутня реалізація (без зміни Book)
// var xmlMapper = new BookXmlMapper("books.xml");
// var dbMapper = new BookDatabaseMapper(connection);

// Так само, як працюємо з List<T>
books.Add(newBook);           // repository.Save(newBook);
var book = books[id];         // repository.FindById(id);
books.Remove(oldBook);        // repository.Delete(oldBook);

namespace Library.Repository;

/// <summary>
/// Базовий інтерфейс Repository.
/// Визначає стандартні CRUD-операції для будь-якої сутності.
/// </summary>
/// <typeparam name="TEntity">Тип сутності</typeparam>
/// <typeparam name="TId">Тип ідентифікатора</typeparam>
public interface IRepository<TEntity, TId> where TEntity : class
{
    /// <summary>
    /// Зберігає сутність.
    /// Якщо сутність нова — створює, якщо існує — оновлює.
    /// </summary>
    /// <param name="entity">Сутність для збереження</param>
    /// <returns>Збережена сутність</returns>
    TEntity Save(TEntity entity);

    /// <summary>
    /// Знаходить сутність за ідентифікатором.
    /// </summary>
    /// <param name="id">Ідентифікатор</param>
    /// <returns>Сутність або null</returns>
    TEntity? FindById(TId id);

    /// <summary>
    /// Повертає всі сутності.
    /// </summary>
    /// <returns>Перелік всіх сутностей</returns>
    IReadOnlyList<TEntity> FindAll();

    /// <summary>
    /// Видаляє сутність за ідентифікатором.
    /// </summary>
    /// <param name="id">Ідентифікатор</param>
    /// <returns>true, якщо сутність було видалено</returns>
    bool DeleteById(TId id);

    /// <summary>
    /// Видаляє конкретну сутність.
    /// </summary>
    /// <param name="entity">Сутність для видалення</param>
    /// <returns>true, якщо сутність було видалено</returns>
    bool Delete(TEntity entity);

    /// <summary>
    /// Перевіряє існування сутності за ідентифікатором.
    /// </summary>
    /// <param name="id">Ідентифікатор</param>
    /// <returns>true, якщо сутність існує</returns>
    bool ExistsById(TId id);

    /// <summary>
    /// Повертає кількість сутностей у сховищі.
    /// </summary>
    /// <returns>Кількість сутностей</returns>
    long Count();
}

using Library.Domain;

namespace Library.Repository;

/// <summary>
/// Репозиторій для роботи з книгами.
/// Розширює базовий IRepository та додає методи, специфічні для домену.
/// </summary>
public interface IBookRepository : IRepository<Book, string>
{
    /// <summary>
    /// Знаходить книги за автором.
    /// </summary>
    /// <param name="author">Ім'я автора</param>
    /// <returns>Список книг автора</returns>
    IReadOnlyList<Book> FindByAuthor(string author);

    /// <summary>
    /// Знаходить книги за назвою (часткове співпадіння).
    /// </summary>
    /// <param name="title">Частина назви</param>
    /// <returns>Список знайдених книг</returns>
    IReadOnlyList<Book> FindByTitleContaining(string title);

    /// <summary>
    /// Знаходить всі доступні книги.
    /// </summary>
    /// <returns>Список доступних книг</returns>
    IReadOnlyList<Book> FindAvailable();

    /// <summary>
    /// Знаходить книгу за ISBN.
    /// </summary>
    /// <param name="isbn">ISBN книги</param>
    /// <returns>Книга або null</returns>
    Book? FindByIsbn(string isbn);

    /// <summary>
    /// Знаходить книги, видані в певному році.
    /// </summary>
    /// <param name="year">Рік видання</param>
    /// <returns>Список книг</returns>
    IReadOnlyList<Book> FindByYear(int year);

    /// <summary>
    /// Знаходить книги, видані в діапазоні років.
    /// </summary>
    /// <param name="startYear">Початковий рік</param>
    /// <param name="endYear">Кінцевий рік</param>
    /// <returns>Список книг</returns>
    IReadOnlyList<Book> FindByYearBetween(int startYear, int endYear);
}

// DAO-стиль (технічний)
IList<Book> Select(string whereClause);

// Repository-стиль (доменний)
IReadOnlyList<Book> FindAvailable();
IReadOnlyList<Book> FindByAuthor(string author);

using System.Text.Json;
using Library.Repository.Exceptions;

namespace Library.Repository.Json;

/// <summary>
/// Абстрактна базова реалізація Repository для JSON-сховища.
/// Містить всю логіку роботи з файлами та System.Text.Json.
/// Конкретні репозиторії наслідують цей клас.
/// </summary>
/// <typeparam name="TEntity">Тип сутності</typeparam>
/// <typeparam name="TId">Тип ідентифікатора</typeparam>
public abstract class JsonRepository<TEntity, TId> : IRepository<TEntity, TId> 
    where TEntity : class
{
    protected readonly string FilePath;
    protected readonly JsonSerializerOptions JsonOptions;
    
    /// <summary>
    /// Функція для отримання ідентифікатора з сутності.
    /// Кожен конкретний репозиторій повинен надати свою реалізацію.
    /// </summary>
    protected readonly Func<TEntity, TId> IdExtractor;

    /// <summary>
    /// Конструктор базового репозиторію.
    /// </summary>
    /// <param name="filename">Шлях до JSON-файлу</param>
    /// <param name="idExtractor">Функція витягування Id з сутності</param>
    protected JsonRepository(string filename, Func<TEntity, TId> idExtractor)
    {
        FilePath = filename;
        IdExtractor = idExtractor;
        JsonOptions = new JsonSerializerOptions
        {
            WriteIndented = true,
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            PropertyNameCaseInsensitive = true
        };
        
        EnsureDirectoryExists();
    }

    /// <summary>
    /// Створює директорію для файлу, якщо вона не існує.
    /// </summary>
    private void EnsureDirectoryExists()
    {
        var directory = Path.GetDirectoryName(FilePath);
        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
        {
            try
            {
                Directory.CreateDirectory(directory);
            }
            catch (IOException ex)
            {
                throw new RepositoryException($"Не вдалося створити директорію: {directory}", ex);
            }
        }
    }

    public virtual TEntity Save(TEntity entity)
    {
        var entities = FindAllInternal();
        var id = IdExtractor(entity);

        // Шукаємо існуючу сутність
        var existingIndex = entities.FindIndex(e => 
            EqualityComparer<TId>.Default.Equals(IdExtractor(e), id));

        if (existingIndex >= 0)
        {
            entities[existingIndex] = entity;
        }
        else
        {
            entities.Add(entity);
        }

        WriteToFile(entities);
        return entity;
    }

    public virtual TEntity? FindById(TId id)
    {
        return FindAllInternal()
            .FirstOrDefault(entity => 
                EqualityComparer<TId>.Default.Equals(IdExtractor(entity), id));
    }

    public virtual IReadOnlyList<TEntity> FindAll()
    {
        return FindAllInternal().AsReadOnly();
    }

    public virtual bool DeleteById(TId id)
    {
        var entities = FindAllInternal();
        var removed = entities.RemoveAll(entity => 
            EqualityComparer<TId>.Default.Equals(IdExtractor(entity), id)) > 0;

        if (removed)
        {
            WriteToFile(entities);
        }
        
        return removed;
    }

    public virtual bool Delete(TEntity entity)
    {
        return DeleteById(IdExtractor(entity));
    }

    public virtual bool ExistsById(TId id)
    {
        return FindById(id) != null;
    }

    public virtual long Count()
    {
        return FindAllInternal().Count;
    }

    /// <summary>
    /// Внутрішній метод для пошуку за предикатом.
    /// Використовується конкретними репозиторіями для реалізації
    /// специфічних методів пошуку.
    /// </summary>
    /// <param name="predicate">Умова фільтрації</param>
    /// <returns>Відфільтрований список</returns>
    protected IReadOnlyList<TEntity> FindBy(Func<TEntity, bool> predicate)
    {
        return FindAllInternal()
            .Where(predicate)
            .ToList()
            .AsReadOnly();
    }

    /// <summary>
    /// Внутрішній метод для знаходження першого елемента за предикатом.
    /// </summary>
    /// <param name="predicate">Умова пошуку</param>
    /// <returns>Перший знайдений елемент або null</returns>
    protected TEntity? FindFirstBy(Func<TEntity, bool> predicate)
    {
        return FindAllInternal().FirstOrDefault(predicate);
    }

    /// <summary>
    /// Читає всі сутності з файлу.
    /// </summary>
    protected List<TEntity> FindAllInternal()
    {
        if (!File.Exists(FilePath))
        {
            return new List<TEntity>();
        }

        try
        {
            var json = File.ReadAllText(FilePath);
            
            if (string.IsNullOrWhiteSpace(json))
            {
                return new List<TEntity>();
            }
            
            return JsonSerializer.Deserialize<List<TEntity>>(json, JsonOptions) 
                   ?? new List<TEntity>();
        }
        catch (JsonException ex)
        {
            throw new RepositoryException($"Помилка десеріалізації файлу: {FilePath}", ex);
        }
        catch (IOException ex)
        {
            throw new RepositoryException($"Помилка читання з файлу: {FilePath}", ex);
        }
    }

    /// <summary>
    /// Записує всі сутності у файл.
    /// </summary>
    protected void WriteToFile(List<TEntity> entities)
    {
        try
        {
            var json = JsonSerializer.Serialize(entities, JsonOptions);
            File.WriteAllText(FilePath, json);
        }
        catch (IOException ex)
        {
            throw new RepositoryException($"Помилка запису у файл: {FilePath}", ex);
        }
    }
}

namespace Library.Repository.Exceptions;

/// <summary>
/// Виняток, що виникає при помилках роботи з репозиторієм.
/// </summary>
public class RepositoryException : Exception
{
    public RepositoryException(string message) : base(message)
    {
    }

    public RepositoryException(string message, Exception innerException) 
        : base(message, innerException)
    {
    }
}

using Library.Domain;

namespace Library.Repository.Json;

/// <summary>
/// JSON-реалізація репозиторію книг.
/// Зберігає книги у JSON-файл та надає методи для роботи з ними.
/// </summary>
public class JsonBookRepository : JsonRepository<Book, string>, IBookRepository
{
    /// <summary>
    /// Створює репозиторій з вказаним шляхом до файлу.
    /// </summary>
    /// <param name="filename">Шлях до JSON-файлу</param>
    public JsonBookRepository(string filename) 
        : base(filename, book => book.Id)  // Lambda для витягування Id
    {
    }

    public IReadOnlyList<Book> FindByAuthor(string author)
    {
        return FindBy(book => 
            book.Author.Contains(author, StringComparison.OrdinalIgnoreCase));
    }

    public IReadOnlyList<Book> FindByTitleContaining(string title)
    {
        return FindBy(book => 
            book.Title.Contains(title, StringComparison.OrdinalIgnoreCase));
    }

    public IReadOnlyList<Book> FindAvailable()
    {
        return FindBy(book => book.IsAvailable);
    }

    public Book? FindByIsbn(string isbn)
    {
        return FindFirstBy(book => book.Isbn == isbn);
    }

    public IReadOnlyList<Book> FindByYear(int year)
    {
        return FindBy(book => book.Year == year);
    }

    public IReadOnlyList<Book> FindByYearBetween(int startYear, int endYear)
    {
        return FindBy(book => book.Year >= startYear && book.Year <= endYear);
    }
}

using Library.Domain;
using Library.Repository;
using Library.Repository.Json;

namespace Library.Application;

public class LibraryApplication
{
    // Залежність від інтерфейсу, не від реалізації!
    private readonly IBookRepository _bookRepository;

    public LibraryApplication(IBookRepository bookRepository)
    {
        _bookRepository = bookRepository;
    }

    public void Run()
    {
        // Створюємо тестові дані
        CreateSampleBooks();

        // Демонструємо можливості репозиторію
        DemonstrateRepositoryCapabilities();
    }

    private void CreateSampleBooks()
    {
        Console.WriteLine("=== Створення книг ===\n");

        var books = new List<Book>
        {
            new("Чистий код", "Роберт Мартін", 2008, "978-0132350884"),
            new("Чиста архітектура", "Роберт Мартін", 2017, "978-0134494166"),
            new("Патерни проєктування", "Банда чотирьох", 1994, "978-0201633610"),
            new("Рефакторинг", "Мартін Фаулер", 1999, "978-0201485677"),
            new("Domain-Driven Design", "Ерік Еванс", 2003, "978-0321125217"),
            new("Effective C#", "Білл Вагнер", 2017, "978-0672337871")
        };

        foreach (var book in books)
        {
            _bookRepository.Save(book);
            Console.WriteLine($"Збережено: {book.Title}");
        }

        Console.WriteLine($"\nВсього книг: {_bookRepository.Count()}");
    }

    private void DemonstrateRepositoryCapabilities()
    {
        Console.WriteLine("\n=== Демонстрація можливостей ===\n");

        // Пошук за автором
        Console.WriteLine("Книги Роберта Мартіна:");
        foreach (var book in _bookRepository.FindByAuthor("Мартін"))
        {
            Console.WriteLine($"  - {book.Title}");
        }

        // Пошук за частиною назви
        Console.WriteLine("\nКниги з 'Чист' у назві:");
        foreach (var book in _bookRepository.FindByTitleContaining("Чист"))
        {
            Console.WriteLine($"  - {book.Title}");
        }

        // Пошук за роками
        Console.WriteLine("\nКниги 2000-2010:");
        foreach (var book in _bookRepository.FindByYearBetween(2000, 2010))
        {
            Console.WriteLine($"  - {book.Title} ({book.Year})");
        }

        // Видача книги
        Console.WriteLine("\n=== Операція видачі книги ===");
        var foundBook = _bookRepository.FindByIsbn("978-0132350884");
        if (foundBook != null)
        {
            Console.WriteLine($"Видаємо: {foundBook.Title}");
            foundBook.Borrow();
            _bookRepository.Save(foundBook);
            Console.WriteLine($"Статус: {(foundBook.IsAvailable ? "доступна" : "видана")}");
        }

        // Доступні книги
        Console.WriteLine("\nДоступні книги:");
        foreach (var book in _bookRepository.FindAvailable())
        {
            Console.WriteLine($"  - {book.Title}");
        }
    }
}

// Точка входу
public static class Program
{
    public static void Main()
    {
        // Ін'єкція залежності — передаємо конкретну реалізацію
        IBookRepository repository = new JsonBookRepository("data/library/books.json");
        var app = new LibraryApplication(repository);
        app.Run();
    }
}