public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public decimal Weight { get; set; }
    public byte[] Thumbnail { get; set; } = Array.Empty<byte>();
    public string Tags { get; set; } = string.Empty; // JSON-рядок
}

public class ProductConfiguration : IEntityTypeConfiguration<Product>
{
    public void Configure(EntityTypeBuilder<Product> builder)
    {
        builder.HasKey(p => p.Id);

        builder.Property(p => p.Name)
               .HasMaxLength(200)
               .IsRequired();

        builder.Property(p => p.Description)
               .HasColumnType("nvarchar(4000)");

        // Явний тип для фінансового значення
        builder.Property(p => p.Price)
               .HasColumnType("decimal(10, 4)");

        // Вага: менша точність достатня
        builder.Property(p => p.Weight)
               .HasColumnType("decimal(8, 3)");

        // Фіксований розмір для мініатюри
        builder.Property(p => p.Thumbnail)
               .HasColumnType("varbinary(8000)");

        // PostgreSQL: явно jsonb замість text
        // builder.Property(p => p.Tags).HasColumnType("jsonb");
    }
}

public class FinancialTransaction
{
    public int Id { get; set; }
    public decimal Amount { get; set; }          // Сума транзакції
    public decimal ExchangeRate { get; set; }    // Курс обміну
    public decimal Fee { get; set; }             // Комісія
    public decimal TaxAmount { get; set; }       // Податок
}

public class FinancialTransactionConfiguration : IEntityTypeConfiguration<FinancialTransaction>
{
    public void Configure(EntityTypeBuilder<FinancialTransaction> builder)
    {
        // Сума: 12 цифр всього, 4 після коми — підходить для сум до 99,999,999.9999
        builder.Property(t => t.Amount)
               .HasPrecision(14, 4)
               .IsRequired();

        // Курс обміну: потрібна висока точність після коми
        builder.Property(t => t.ExchangeRate)
               .HasPrecision(18, 8);

        // Комісія: менші суми, менша точність
        builder.Property(t => t.Fee)
               .HasPrecision(10, 2);

        // Податок: аналогічно до суми
        builder.Property(t => t.TaxAmount)
               .HasPrecision(14, 4);
    }
}

CREATE TABLE [FinancialTransactions] (
    [Id]           INT             NOT NULL IDENTITY,
    [Amount]       DECIMAL(14, 4)  NOT NULL,
    [ExchangeRate] DECIMAL(18, 8)  NOT NULL,
    [Fee]          DECIMAL(10, 2)  NOT NULL,
    [TaxAmount]    DECIMAL(14, 4)  NOT NULL,
    CONSTRAINT [PK_FinancialTransactions] PRIMARY KEY ([Id])
);

// Повна форма: явний ValueConverter<TModel, TProvider>
// TModel — тип у C# (ваш клас або enum)
// TProvider — тип у БД (string, int, byte[], тощо)

var converter = new ValueConverter<OrderStatus, string>(
    // convertToProviderExpression: C# → БД
    v => v.ToString(),
    // convertFromProviderExpression: БД → C#
    v => Enum.Parse<OrderStatus>(v)
);

-- Без конвертера: числа незрозумілі
SELECT * FROM Orders WHERE Status = 2; -- 2 — це що?

-- З конвертером на string:
SELECT * FROM Orders WHERE Status = 'Shipped'; -- зрозуміло!

public enum OrderStatus
{
    Pending,
    Processing,
    Shipped,
    Delivered,
    Cancelled,
    Refunded
}

public class Order
{
    public int Id { get; set; }
    public OrderStatus Status { get; set; }
    public string CustomerName { get; set; } = string.Empty;
    public decimal TotalAmount { get; set; }
}

public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> builder)
    {
        builder.HasKey(o => o.Id);

        // HasConversion<string>: enum → рядок, рядок → enum
        builder.Property(o => o.Status)
               .HasConversion<string>()
               .HasMaxLength(50);

        builder.Property(o => o.CustomerName)
               .IsRequired()
               .HasMaxLength(200);

        builder.Property(o => o.TotalAmount)
               .HasPrecision(14, 2);
    }
}

INSERT INTO [Orders] ([CustomerName], [Status], [TotalAmount])
VALUES ('John Doe', 'Shipped', 150.00);

public class OrderStatusConverter : ValueConverter<OrderStatus, string>
{
    private static readonly Dictionary<OrderStatus, string> _toDb = new()
    {
        [OrderStatus.Pending]    = "pnd",
        [OrderStatus.Processing] = "prc",
        [OrderStatus.Shipped]    = "shp",
        [OrderStatus.Delivered]  = "dlv",
        [OrderStatus.Cancelled]  = "cnl",
        [OrderStatus.Refunded]   = "rfd"
    };

    private static readonly Dictionary<string, OrderStatus> _fromDb =
        _toDb.ToDictionary(kvp => kvp.Value, kvp => kvp.Key);

    public OrderStatusConverter() : base(
        v => _toDb[v],
        v => _fromDb[v])
    { }
}

// Використання:
builder.Property(o => o.Status)
       .HasConversion(new OrderStatusConverter())
       .HasMaxLength(3)
       .IsUnicode(false); // ASCII достатньо для кодів

// Без Strongly Typed IDs: компілятор не помітить помилку
public async Task<Order?> GetOrdersByCustomer(int orderId, int customerId)
{
    // ...
}

// Виклик з переставленими аргументами — компілятор мовчить!
var order = await GetOrdersByCustomer(customerId, orderId);

// Strongly Typed IDs через readonly struct
public readonly struct CustomerId : IEquatable<CustomerId>
{
    public int Value { get; }

    public CustomerId(int value)
    {
        if (value <= 0) throw new ArgumentException("CustomerId must be positive", nameof(value));
        Value = value;
    }

    public bool Equals(CustomerId other) => Value == other.Value;
    public override bool Equals(object? obj) => obj is CustomerId other && Equals(other);
    public override int GetHashCode() => Value.GetHashCode();
    public override string ToString() => $"Customer#{Value}";

    public static implicit operator int(CustomerId id) => id.Value;
    public static explicit operator CustomerId(int value) => new(value);
}

public readonly struct OrderId : IEquatable<OrderId>
{
    public int Value { get; }
    public OrderId(int value) => Value = value;
    public bool Equals(OrderId other) => Value == other.Value;
    public override bool Equals(object? obj) => obj is OrderId other && Equals(other);
    public override int GetHashCode() => Value.GetHashCode();
    public static implicit operator int(OrderId id) => id.Value;
    public static explicit operator OrderId(int value) => new(value);
}

public class Customer
{
    public CustomerId Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public ICollection<Order> Orders { get; set; } = new List<Order>();
}

public class Order
{
    public OrderId Id { get; set; }
    public CustomerId CustomerId { get; set; } // FK через Strongly Typed ID
    public Customer Customer { get; set; } = null!;
    public decimal TotalAmount { get; set; }
}

public class CustomerConfiguration : IEntityTypeConfiguration<Customer>
{
    public void Configure(EntityTypeBuilder<Customer> builder)
    {
        // Конвертер: CustomerId ↔ int
        builder.HasKey(c => c.Id);
        builder.Property(c => c.Id)
               .HasConversion(
                   id => id.Value,              // CustomerId → int (у БД)
                   value => new CustomerId(value) // int → CustomerId (з БД)
               );

        builder.Property(c => c.Name)
               .IsRequired()
               .HasMaxLength(200);
    }
}

public class OrderConfiguration : IEntityTypeConfiguration<Order>
{
    public void Configure(EntityTypeBuilder<Order> builder)
    {
        builder.HasKey(o => o.Id);
        builder.Property(o => o.Id)
               .HasConversion(
                   id => id.Value,
                   value => new OrderId(value)
               );

        // FK теж потребує конвертера
        builder.Property(o => o.CustomerId)
               .HasConversion(
                   id => id.Value,
                   value => new CustomerId(value)
               );

        builder.HasOne(o => o.Customer)
               .WithMany(c => c.Orders)
               .HasForeignKey(o => o.CustomerId);

        builder.Property(o => o.TotalAmount)
               .HasPrecision(14, 2);
    }
}

// Без Strongly Typed IDs:
void Process(int orderId, int customerId) { ... }
Process(customerId, orderId); // ← мовчить! Помилка лише в рантаймі

// Зі Strongly Typed IDs:
void Process(OrderId orderId, CustomerId customerId) { ... }
Process(customerId, orderId); // ← помилка компіляції! CustomerId ≠ OrderId

public class UserPreferences
{
    public string Theme { get; set; } = "light";
    public string Language { get; set; } = "uk";
    public bool EmailNotifications { get; set; } = true;
    public List<string> FavoriteCategories { get; set; } = new();
    public Dictionary<string, int> CustomSettings { get; set; } = new();
}

public class User
{
    public int Id { get; set; }
    public string Email { get; set; } = string.Empty;

    // Складний об'єкт → зберігається як JSON у single column
    public UserPreferences Preferences { get; set; } = new();
}

public class UserConfiguration : IEntityTypeConfiguration<User>
{
    public void Configure(EntityTypeBuilder<User> builder)
    {
        builder.HasKey(u => u.Id);

        builder.Property(u => u.Email)
               .IsRequired()
               .HasMaxLength(320);

        // Конвертер: UserPreferences ↔ JSON string
        builder.Property(u => u.Preferences)
               .HasConversion(
                   prefs => JsonSerializer.Serialize(prefs, JsonOptions),
                   json  => JsonSerializer.Deserialize<UserPreferences>(json, JsonOptions)
                         ?? new UserPreferences()
               )
               .HasColumnType("nvarchar(max)");
    }

    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
    };
}

public class EncryptedStringConverter : ValueConverter<string, string>
{
    public EncryptedStringConverter(string encryptionKey) : base(
        v => Encrypt(v, encryptionKey),
        v => Decrypt(v, encryptionKey))
    { }

    private static string Encrypt(string plainText, string key)
    {
        using var aes = Aes.Create();
        aes.Key = Convert.FromHexString(key);
        aes.GenerateIV();

        using var encryptor = aes.CreateEncryptor();
        var plainBytes = Encoding.UTF8.GetBytes(plainText);
        var cipherBytes = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length);

        // Зберігаємо IV разом із шифротекстом: IV (16 bytes) + ciphertext
        var result = new byte[aes.IV.Length + cipherBytes.Length];
        aes.IV.CopyTo(result, 0);
        cipherBytes.CopyTo(result, aes.IV.Length);

        return Convert.ToBase64String(result);
    }

    private static string Decrypt(string cipherBase64, string key)
    {
        var fullCipher = Convert.FromBase64String(cipherBase64);

        using var aes = Aes.Create();
        aes.Key = Convert.FromHexString(key);

        // Перші 16 байт — IV
        var iv = fullCipher[..16];
        var cipherBytes = fullCipher[16..];
        aes.IV = iv;

        using var decryptor = aes.CreateDecryptor();
        var plainBytes = decryptor.TransformFinalBlock(cipherBytes, 0, cipherBytes.Length);
        return Encoding.UTF8.GetString(plainBytes);
    }
}

public class PatientRecord
{
    public int Id { get; set; }
    public string PatientName { get; set; } = string.Empty; // Шифруємо
    public string SocialSecurityNumber { get; set; } = string.Empty; // Шифруємо
    public string Diagnosis { get; set; } = string.Empty; // Шифруємо
    public DateTime BirthDate { get; set; }
}

public class PatientRecordConfiguration : IEntityTypeConfiguration<PatientRecord>
{
    private readonly string _encryptionKey;

    public PatientRecordConfiguration(string encryptionKey)
    {
        _encryptionKey = encryptionKey;
    }

    public void Configure(EntityTypeBuilder<PatientRecord> builder)
    {
        var converter = new EncryptedStringConverter(_encryptionKey);

        builder.Property(p => p.PatientName)
               .HasConversion(converter)
               .HasMaxLength(500); // Шифрований текст довший за початковий

        builder.Property(p => p.SocialSecurityNumber)
               .HasConversion(converter)
               .HasMaxLength(500);

        builder.Property(p => p.Diagnosis)
               .HasConversion(converter)
               .HasColumnType("nvarchar(max)");
    }
}

using Microsoft.EntityFrameworkCore.Storage.ValueConversion;

// EnumToStringConverter<TEnum>: enum → string і назад
builder.Property(e => e.Status)
       .HasConversion(new EnumToStringConverter<OrderStatus>());

// BoolToZeroOneConverter<TProvider>: bool → 0/1 як числовий тип
builder.Property(e => e.IsActive)
       .HasConversion(new BoolToZeroOneConverter<int>());

// BoolToStringConverter: bool → кастомні рядки ("Y"/"N", "true"/"false")
builder.Property(e => e.IsVerified)
       .HasConversion(new BoolToStringConverter("N", "Y"))
       .HasMaxLength(1)
       .IsUnicode(false);

// DateTimeKindValueConverter: додає Kind до DateTime при читанні
// Корисно для провайдерів, що не зберігають Kind
builder.Property(e => e.CreatedAt)
       .HasConversion(new DateTimeKindValueConverter(DateTimeKind.Utc));

// TimeSpanToTicksConverter: TimeSpan → long (ticks)
builder.Property(e => e.Duration)
       .HasConversion(new TimeSpanToTicksConverter());

// TimeSpanToStringConverter: TimeSpan → "hh:mm:ss" рядок
builder.Property(e => e.WorkingHours)
       .HasConversion(new TimeSpanToStringConverter());

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // Застосовуємо конвертер до ВСІХ властивостей типу OrderStatus у ВСІХ сутностях
    modelBuilder.Properties<OrderStatus>()
                .HaveConversion<string>()
                .HaveMaxLength(50);

    // Застосовуємо до всіх DateTime: додаємо Kind = Utc
    modelBuilder.Properties<DateTime>()
                .HaveConversion(new DateTimeKindValueConverter(DateTimeKind.Utc));

    modelBuilder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly);
}