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<Sale> Sales { get; set; }
    public DbSet<Order> Orders { get; set; }
    public DbSet<OrderItem> OrderItems { get; set; }
    public DbSet<Invoice> Invoices { 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<RideCancelRequest> RideCancelRequests { 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; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // OrderItem uses its inherited Template.Id as PK (no composite key on
        // {FK_OrderId, FK_ItemId}) so that editing a PO's items can soft-delete the current
        // row and insert a fresh one for the same item — versioning per order_invoice_lifecycle.md.
        modelBuilder.Entity<OrderItem>()
            .HasIndex(oi => oi.FK_OrderId);

        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<User>()
            .HasOne(u => u.ReportsTo)
            .WithMany()
            .HasForeignKey(u => u.FK_ReportsToUserId)
            .OnDelete(DeleteBehavior.Restrict);

        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<Order>()
            .HasIndex(o => o.FK_SaleId)
            .IsUnique();

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

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

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

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

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

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

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

        modelBuilder.Entity<Order>()
            .HasOne(o => o.Sale)
            .WithMany()
            .HasForeignKey(o => o.FK_SaleId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

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

        modelBuilder.Entity<Order>()
            .HasOne(o => o.ConfirmedByUser)
            .WithMany()
            .HasForeignKey(o => o.ConfirmedByUserId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

        // Order.InvoiceId is a plain column with no DB-level FK constraint — deliberately
        // unmapped as a relationship, per order_invoice_lifecycle.md.
        modelBuilder.Entity<Order>()
            .Property(o => o.InvoiceId)
            .HasColumnName("InvoiceId");

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

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

        modelBuilder.Entity<Invoice>()
            .HasOne(i => i.PrintedByUser)
            .WithMany()
            .HasForeignKey(i => i.PrintedByUserId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

        modelBuilder.Entity<Invoice>()
            .HasOne(i => i.FinalizedByUser)
            .WithMany()
            .HasForeignKey(i => i.FinalizedByUserId)
            .OnDelete(DeleteBehavior.Restrict)
            .IsRequired(false);

        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.Order)
            .WithMany()
            .HasForeignKey(r => r.FK_OrderId)
            .OnDelete(DeleteBehavior.Restrict);

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

        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();

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

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

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

        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<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<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<PurchaseOrderItem>()
            .HasIndex(i => i.FK_PurchaseOrderId);

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

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

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

        modelBuilder.Entity<SaleReturn>()
            .HasOne(r => r.Order)
            .WithMany()
            .HasForeignKey(r => r.FK_OrderId)
            .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);

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

        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);

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

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

        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();

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