using Microsoft.EntityFrameworkCore;
using SlipItIn.Shared.Models;

namespace SlipItIn.Server.Data;

public class SlipItInDbContext : DbContext
{
    public SlipItInDbContext(DbContextOptions<SlipItInDbContext> options) : base(options) { }

    public DbSet<User> Users { get; set; }
    public DbSet<Phrase> Phrases { get; set; }
    public DbSet<Game> Games { get; set; }
    public DbSet<Player> Players { get; set; }
    public DbSet<PlayerCard> PlayerCards { get; set; }
    public DbSet<GameRound> GameRounds { get; set; }
    public DbSet<SlipChallenge> SlipChallenges { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // User
        modelBuilder.Entity<User>()
            .HasIndex(u => u.Username).IsUnique();
        modelBuilder.Entity<User>()
            .HasIndex(u => u.Email).IsUnique();

        // Game
        modelBuilder.Entity<Game>()
            .HasIndex(g => g.LobbyCode).IsUnique();
        modelBuilder.Entity<Game>()
            .HasOne(g => g.Host)
            .WithMany()
            .HasForeignKey(g => g.HostId)
            .OnDelete(DeleteBehavior.Restrict);

        // Player
        modelBuilder.Entity<Player>()
            .HasOne(p => p.User)
            .WithMany(u => u.Players)
            .HasForeignKey(p => p.UserId)
            .OnDelete(DeleteBehavior.Cascade);
        modelBuilder.Entity<Player>()
            .HasOne(p => p.Game)
            .WithMany(g => g.Players)
            .HasForeignKey(p => p.GameId)
            .OnDelete(DeleteBehavior.Cascade);
        modelBuilder.Entity<Player>()
            .HasIndex(p => new { p.GameId, p.UserId }).IsUnique();

        // PlayerCard
        modelBuilder.Entity<PlayerCard>()
            .HasOne(pc => pc.Player)
            .WithMany(p => p.Cards)
            .HasForeignKey(pc => pc.PlayerId)
            .OnDelete(DeleteBehavior.Cascade);
        modelBuilder.Entity<PlayerCard>()
            .HasOne(pc => pc.Phrase)
            .WithMany(ph => ph.PlayerCards)
            .HasForeignKey(pc => pc.PhraseId)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<PlayerCard>()
            .HasOne(pc => pc.GameRound)
            .WithMany(gr => gr.ActiveCards)
            .HasForeignKey(pc => pc.GameRoundId)
            .OnDelete(DeleteBehavior.Cascade);

        // GameRound
        modelBuilder.Entity<GameRound>()
            .HasOne(gr => gr.Game)
            .WithMany(g => g.Rounds)
            .HasForeignKey(gr => gr.GameId)
            .OnDelete(DeleteBehavior.Cascade);

        // SlipChallenge
        modelBuilder.Entity<SlipChallenge>()
            .HasOne(sc => sc.GameRound)
            .WithMany(gr => gr.Challenges)
            .HasForeignKey(sc => sc.GameRoundId)
            .OnDelete(DeleteBehavior.Cascade);
        modelBuilder.Entity<SlipChallenge>()
            .HasOne(sc => sc.ChallengingPlayer)
            .WithMany()
            .HasForeignKey(sc => sc.ChallengingPlayerId)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<SlipChallenge>()
            .HasOne(sc => sc.TargetPlayer)
            .WithMany()
            .HasForeignKey(sc => sc.TargetPlayerId)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<SlipChallenge>()
            .HasOne(sc => sc.TargetCard)
            .WithMany()
            .HasForeignKey(sc => sc.TargetCardId)
            .OnDelete(DeleteBehavior.Restrict);
    }
}