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<Order> Orders { get; set; }
    public DbSet<OrderItem> OrderItems { 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; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<OrderItem>()
            .HasKey(oi => new { oi.FK_OrderId, oi.FK_ItemId });

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

        Seed.RoleAndPermissionSeed.Apply(modelBuilder);
    }
}