using Distribution.Models;
using Microsoft.EntityFrameworkCore;

namespace Distribution.Data;

public class AppDBContext(DbContextOptions<AppDBContext> options) : DbContext(options)
{
    public DbSet<Region> Regions { get; set; }
    public DbSet<Models.Route> Routes { get; set; }
    public DbSet<Vehicle> Vehicles { get; set; }
    public DbSet<Store> Stores { get; set; }
    public DbSet<Warehouse> Warehouses { get; set; }
    public DbSet<Category> Categories { get; set; }
    public DbSet<SubCategory> SubCategories { get; set; }
    public DbSet<Brand> Brands { get; set; }
    public DbSet<Uom> Uoms { get; set; }
    public DbSet<UomConversion> UomConversions { get; set; }
    public DbSet<Item> Items { get; set; }
    public DbSet<SaleRoute> SaleRoutes { get; set; }
    public DbSet<ShopPO> ShopPOs { get; set; }
    public DbSet<ShopPOItem> ShopPOItems { get; set; }
    public DbSet<Invoice> Invoices { get; set; }
    public DbSet<LoadingSheetOrder> LoadingSheetOrders { get; set; }
    public DbSet<DeliveryRun> DeliveryRuns { get; set; }
    public DbSet<User> Users { get; set; }
    public DbSet<Role> Roles { get; set; }
    public DbSet<Permission> Permissions { get; set; }
    public DbSet<RolePermission> RolePermissions { get; set; }
    public DbSet<UserRegionScope> UserRegionScopes { get; set; }
    public DbSet<UserRouteScope> UserRouteScopes { get; set; }
    public DbSet<UserStoreScope> UserStoreScopes { get; set; }
    public DbSet<StockBalance> StockBalances { get; set; }
    public DbSet<StockMovement> StockMovements { get; set; }
    public DbSet<StoreKycDocument> StoreKycDocuments { get; set; }
    public DbSet<PriceList> PriceLists { get; set; }
    public DbSet<PriceListItem> PriceListItems { get; set; }
    public DbSet<Supplier> Suppliers { get; set; }
    public DbSet<DriverProfile> DriverProfiles { get; set; }
    public DbSet<DriverComplianceConfig> DriverComplianceConfigs { get; set; }
    public DbSet<Scheme> Schemes { get; set; }
    public DbSet<SchemeRedemption> SchemeRedemptions { get; set; }
    public DbSet<SchemeBundleComponent> SchemeBundleComponents { get; set; }
    public DbSet<LoadingSheet> LoadingSheets { get; set; }
    public DbSet<LoadingSheetItem> LoadingSheetItems { get; set; }
    public DbSet<Payment> Payments { get; set; }
    public DbSet<DeliveryTask> DeliveryTasks { get; set; }
    public DbSet<PurchaseOrder> PurchaseOrders { get; set; }
    public DbSet<PurchaseOrderItem> PurchaseOrderItems { get; set; }
    public DbSet<GoodsReceipt> GoodsReceipts { get; set; }
    public DbSet<GoodsReceiptItem> GoodsReceiptItems { get; set; }
    public DbSet<PurchaseReturn> PurchaseReturns { get; set; }
    public DbSet<PurchaseReturnItem> PurchaseReturnItems { get; set; }
    public DbSet<SaleReturn> SaleReturns { get; set; }
    public DbSet<SaleReturnItem> SaleReturnItems { get; set; }
    public DbSet<CreditNote> CreditNotes { get; set; }
    public DbSet<Claim> Claims { get; set; }
    public DbSet<SupplierClaim> SupplierClaims { get; set; }
    public DbSet<SupplierClaimItem> SupplierClaimItems { get; set; }
    public DbSet<RegionalTarget> RegionalTargets { get; set; }
    public DbSet<RegionalBudget> RegionalBudgets { get; set; }
    public DbSet<RegionAgencyMap> RegionAgencyMaps { get; set; }
    public DbSet<RegionalTaxRule> RegionalTaxRules { get; set; }
    public DbSet<RouteVisitLog> RouteVisitLogs { get; set; }
    public DbSet<SysConfig> SysConfigs { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // --- Composite PKs ---

        modelBuilder.Entity<RolePermission>()
            .HasKey(rp => new { rp.FK_RoleId, rp.FK_PermissionId });

        modelBuilder.Entity<UserRegionScope>()
            .HasKey(s => new { s.FK_UserId, s.FK_RegionId });

        modelBuilder.Entity<UserRouteScope>()
            .HasKey(s => new { s.FK_UserId, s.FK_RouteId });

        modelBuilder.Entity<UserStoreScope>()
            .HasKey(s => new { s.FK_UserId, s.FK_StoreId });

        modelBuilder.Entity<LoadingSheetOrder>()
            .HasKey(lo => new { lo.FK_LoadingSheetId, lo.FK_ShopPOId });

        // --- Unique indexes ---

        modelBuilder.Entity<StockBalance>()
            .HasIndex(sb => new { sb.FK_ItemId, sb.LocationId })
            .IsUnique();

        modelBuilder.Entity<PriceListItem>()
            .HasIndex(pli => new { pli.FK_PriceListId, pli.FK_ItemId })
            .IsUnique();

        modelBuilder.Entity<DriverProfile>()
            .HasIndex(dp => dp.FK_UserId)
            .IsUnique();

        // --- User ---

        modelBuilder.Entity<User>()
            .HasOne(u => u.ReportsTo)
            .WithMany()
            .HasForeignKey(u => u.FK_ReportsToUserId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- Vehicle ---

        modelBuilder.Entity<Vehicle>()
            .HasOne<Warehouse>()
            .WithMany()
            .HasForeignKey(nameof(Vehicle.DefaultWarehouseId))
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

        // --- DeliveryRun ---

        modelBuilder.Entity<DeliveryRun>()
            .HasOne(r => r.DriverProfile)
            .WithMany()
            .HasForeignKey(r => r.FK_DriverProfileId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- ShopPO ---

        modelBuilder.Entity<ShopPO>()
            .HasOne(p => p.Store)
            .WithMany()
            .HasForeignKey(p => p.FK_StoreId)
            .OnDelete(DeleteBehavior.Restrict);

        // InvoiceId is a plain column — no FK constraint
        modelBuilder.Entity<ShopPO>()
            .Property(p => p.InvoiceId)
            .HasColumnName("InvoiceId");

        // --- ShopPOItem ---

        modelBuilder.Entity<ShopPOItem>()
            .HasOne(i => i.ShopPO)
            .WithMany(p => p.Items)
            .HasForeignKey(i => i.FK_ShopPOId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<ShopPOItem>()
            .HasOne(i => i.Item)
            .WithMany()
            .HasForeignKey(i => i.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- Invoice ---

        modelBuilder.Entity<Invoice>()
            .HasOne(i => i.ShopPO)
            .WithMany()
            .HasForeignKey(i => i.FK_ShopPOId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<Invoice>()
            .HasMany(i => i.Payments)
            .WithOne(p => p.Invoice)
            .HasForeignKey(p => p.FK_InvoiceId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- LoadingSheet ---

        modelBuilder.Entity<LoadingSheet>()
            .HasOne(s => s.Ride)
            .WithMany()
            .HasForeignKey(s => s.FK_RideId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- LoadingSheetOrder ---

        modelBuilder.Entity<LoadingSheetOrder>()
            .HasOne(lo => lo.LoadingSheet)
            .WithMany(s => s.Orders)
            .HasForeignKey(lo => lo.FK_LoadingSheetId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<LoadingSheetOrder>()
            .HasOne(lo => lo.ShopPO)
            .WithMany()
            .HasForeignKey(lo => lo.FK_ShopPOId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- LoadingSheetItem ---

        modelBuilder.Entity<LoadingSheetItem>()
            .HasOne(i => i.LoadingSheet)
            .WithMany(s => s.Items)
            .HasForeignKey(i => i.FK_LoadingSheetId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<LoadingSheetItem>()
            .HasOne(i => i.Item)
            .WithMany()
            .HasForeignKey(i => i.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<LoadingSheetItem>()
            .HasOne(i => i.Warehouse)
            .WithMany()
            .HasForeignKey(i => i.FK_WarehouseId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<LoadingSheetItem>()
            .HasOne(i => i.ShopPOItem)
            .WithMany()
            .HasForeignKey(i => i.FK_ShopPOItemId)
            .OnDelete(DeleteBehavior.SetNull)
            .IsRequired(false);

        // --- SchemeRedemption ---

        modelBuilder.Entity<SchemeRedemption>()
            .HasOne(r => r.Scheme)
            .WithMany(s => s.Redemptions)
            .HasForeignKey(r => r.FK_SchemeId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SchemeRedemption>()
            .HasOne(r => r.ShopPO)
            .WithMany()
            .HasForeignKey(r => r.FK_ShopPOId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

        modelBuilder.Entity<SchemeRedemption>()
            .HasOne(r => r.FreeItem)
            .WithMany()
            .HasForeignKey(r => r.FK_FreeItemId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- Scheme ---

        modelBuilder.Entity<Scheme>()
            .HasOne(s => s.TriggerItem)
            .WithMany()
            .HasForeignKey(s => s.FK_TriggerItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<Scheme>()
            .HasOne(s => s.FreeItem)
            .WithMany()
            .HasForeignKey(s => s.FK_FreeItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SchemeBundleComponent>()
            .HasOne(c => c.Scheme)
            .WithMany(s => s.BundleComponents)
            .HasForeignKey(c => c.FK_SchemeId)
            .OnDelete(DeleteBehavior.Cascade);

        modelBuilder.Entity<SchemeBundleComponent>()
            .HasOne(c => c.Item)
            .WithMany()
            .HasForeignKey(c => c.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SchemeBundleComponent>()
            .HasIndex(c => new { c.FK_SchemeId, c.FK_ItemId })
            .IsUnique();

        // --- PurchaseOrder ---

        modelBuilder.Entity<PurchaseOrder>()
            .HasOne(po => po.Supplier)
            .WithMany()
            .HasForeignKey(po => po.FK_SupplierId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<PurchaseOrderItem>()
            .HasOne(i => i.PurchaseOrder)
            .WithMany(po => po.Items)
            .HasForeignKey(i => i.FK_PurchaseOrderId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<PurchaseOrderItem>()
            .HasOne(i => i.Item)
            .WithMany()
            .HasForeignKey(i => i.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<PurchaseOrderItem>()
            .HasIndex(i => i.FK_PurchaseOrderId);

        // --- GoodsReceipt ---

        modelBuilder.Entity<GoodsReceipt>()
            .HasOne(gr => gr.PurchaseOrder)
            .WithMany()
            .HasForeignKey(gr => gr.FK_PurchaseOrderId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<GoodsReceipt>()
            .HasOne(gr => gr.Warehouse)
            .WithMany()
            .HasForeignKey(gr => gr.FK_WarehouseId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<GoodsReceiptItem>()
            .HasOne(i => i.GoodsReceipt)
            .WithMany(gr => gr.Items)
            .HasForeignKey(i => i.FK_GoodsReceiptId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<GoodsReceiptItem>()
            .HasOne(i => i.PurchaseOrderItem)
            .WithMany()
            .HasForeignKey(i => i.FK_PurchaseOrderItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<GoodsReceiptItem>()
            .HasIndex(i => i.FK_GoodsReceiptId);

        modelBuilder.Entity<GoodsReceiptItem>()
            .HasIndex(i => i.FK_PurchaseOrderItemId);

        // --- PurchaseReturn ---

        modelBuilder.Entity<PurchaseReturn>()
            .HasOne(pr => pr.PurchaseOrder)
            .WithMany()
            .HasForeignKey(pr => pr.FK_PurchaseOrderId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<PurchaseReturnItem>()
            .HasOne(i => i.PurchaseReturn)
            .WithMany(pr => pr.Items)
            .HasForeignKey(i => i.FK_PurchaseReturnId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<PurchaseReturnItem>()
            .HasOne(i => i.Item)
            .WithMany()
            .HasForeignKey(i => i.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<PurchaseReturnItem>()
            .HasIndex(i => i.FK_PurchaseReturnId);

        // --- SaleReturn ---

        modelBuilder.Entity<SaleReturn>()
            .HasOne(r => r.ShopPO)
            .WithMany()
            .HasForeignKey(r => r.FK_ShopPOId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SaleReturn>()
            .HasOne(r => r.CreatedByUser)
            .WithMany()
            .HasForeignKey(r => r.CreatedByUserId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SaleReturnItem>()
            .HasOne(i => i.SaleReturn)
            .WithMany(r => r.Items)
            .HasForeignKey(i => i.FK_SaleReturnId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SaleReturnItem>()
            .HasOne(i => i.Item)
            .WithMany()
            .HasForeignKey(i => i.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SaleReturnItem>()
            .HasIndex(i => i.FK_SaleReturnId);

        // --- CreditNote ---

        modelBuilder.Entity<CreditNote>()
            .HasOne(n => n.SaleReturn)
            .WithMany()
            .HasForeignKey(n => n.FK_SaleReturnId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- Claims ---

        modelBuilder.Entity<Claim>()
            .HasOne(c => c.AgencyUser)
            .WithMany()
            .HasForeignKey(c => c.FK_AgencyUserId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<Claim>()
            .HasOne(c => c.SettledByUser)
            .WithMany()
            .HasForeignKey(c => c.SettledByUserId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SupplierClaim>()
            .HasOne(c => c.PurchaseOrder)
            .WithMany()
            .HasForeignKey(c => c.FK_PurchaseOrderId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SupplierClaim>()
            .HasOne(c => c.GoodsReceipt)
            .WithMany()
            .HasForeignKey(c => c.FK_GoodsReceiptId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

        modelBuilder.Entity<SupplierClaim>()
            .HasOne(c => c.RaisedByUser)
            .WithMany()
            .HasForeignKey(c => c.RaisedByUserId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SupplierClaim>()
            .HasOne(c => c.ResolvedByUser)
            .WithMany()
            .HasForeignKey(c => c.ResolvedByUserId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SupplierClaimItem>()
            .HasOne(i => i.SupplierClaim)
            .WithMany(c => c.Items)
            .HasForeignKey(i => i.FK_SupplierClaimId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SupplierClaimItem>()
            .HasOne(i => i.Item)
            .WithMany()
            .HasForeignKey(i => i.FK_ItemId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<SupplierClaimItem>()
            .HasIndex(i => i.FK_SupplierClaimId);

        // --- DeliveryTask ---

        modelBuilder.Entity<DeliveryTask>()
            .HasOne(t => t.Ride)
            .WithMany()
            .HasForeignKey(t => t.FK_RideId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<DeliveryTask>()
            .HasOne(t => t.ShopPO)
            .WithMany()
            .HasForeignKey(t => t.FK_ShopPOId)
            .OnDelete(DeleteBehavior.Restrict);

        // --- Regional ---

        modelBuilder.Entity<RegionalTarget>()
            .HasIndex(t => new { t.FK_RegionId, t.Period })
            .IsUnique();

        modelBuilder.Entity<RegionalBudget>()
            .HasIndex(b => new { b.FK_RegionId, b.Period })
            .IsUnique();

        modelBuilder.Entity<RegionAgencyMap>()
            .HasIndex(m => new { m.FK_RegionId, m.FK_AgencyUserId })
            .IsUnique();

        modelBuilder.Entity<RegionAgencyMap>()
            .HasOne(m => m.AgencyUser)
            .WithMany()
            .HasForeignKey(m => m.FK_AgencyUserId)
            .OnDelete(DeleteBehavior.Restrict);

        modelBuilder.Entity<RegionalTaxRule>()
            .HasIndex(r => r.FK_RegionId)
            .IsUnique();

        // --- SysConfig ---

        modelBuilder.Entity<SysConfig>()
            .HasKey(c => c.Key);

        modelBuilder.Entity<SysConfig>()
            .Property(c => c.Key)
            .HasMaxLength(100);

        modelBuilder.Entity<SysConfig>().HasData(
            new SysConfig { Key = "InvoiceCreationMode", Value = "ModeB", UpdatedAt = new DateTime(2026, 9, 17), UpdatedBy = null }
        );

        Seed.RoleAndPermissionSeed.Apply(modelBuilder);
        Seed.MasterDataSeed.Apply(modelBuilder);
        Seed.OperationsDataSeed.Apply(modelBuilder);
        Seed.ProcurementSeed.Apply(modelBuilder);
        Seed.CommerceSeed.Apply(modelBuilder);
        Seed.OperationsExtrasSeed.Apply(modelBuilder);
    }
}