using GamificationService.Models.Database;
using Microsoft.EntityFrameworkCore;

namespace GamificationService.Database;

public class ApplicationContext : DbContext
{
    public ApplicationContext(DbContextOptions<ApplicationContext> options) : base(options)
    {}
    
    public required DbSet<Rank> Ranks { get; set; }
    public required DbSet<Skill> Skills { get; set; }
    public required DbSet<Player> Players { get; set; }
    public required DbSet<MissionCategory> MissionCategories { get; set; }
    public required DbSet<Mission> Missions { get; set; }
    public required DbSet<MissionRankRule> MissionRankRules { get; set; }
    public required DbSet<MissionSkillReward> MissionSkillRewards { get; set; }
    public required DbSet<MissionItemReward> MissionItemRewards { get; set; }
    public required DbSet<RankMissionRule> RankMissionRules { get; set; }
    public required DbSet<RankSkillRule> RankSkillRules { get; set; }
    public required DbSet<PlayerSkill> PlayerSkills { get; set; }
    public required DbSet<PlayerMission> PlayerMissions { get; set; }
    public required DbSet<Dialogue> Dialogues { get; set; }
    public required DbSet<DialogueMessage> DialogueMessages { get; set; }
    public required DbSet<DialogueMessageResponseOption> DialogueMessageResponseOptions { get; set; }

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

        // Player configurations
        modelBuilder.Entity<Player>()
            .HasIndex(p => p.UserId)
            .IsUnique();
        modelBuilder.Entity<Player>()
            .HasOne(p => p.Rank)
            .WithMany(r => r.Players)
            .HasForeignKey(p => p.RankId);

        // Rank configurations
        modelBuilder.Entity<Rank>()
            .HasIndex(r => r.ExpNeeded)
            .IsUnique();
        modelBuilder.Entity<Rank>()
            .HasIndex(r => r.Title)
            .IsUnique();

        // Skill configurations
        modelBuilder.Entity<Skill>()
            .HasIndex(s => s.Title)
            .IsUnique();

        // MissionCategory configurations
        modelBuilder.Entity<MissionCategory>()
            .HasIndex(mc => mc.Title)
            .IsUnique();

        // Mission configurations
        modelBuilder.Entity<Mission>()
            .HasOne(m => m.MissionCategory)
            .WithMany(mc => mc.Missions)
            .HasForeignKey(m => m.MissionCategoryId)
            .IsRequired();
        modelBuilder.Entity<Mission>()
            .HasOne(m => m.ParentMission)
            .WithMany(m => m.ChildMissions)
            .HasForeignKey(m => m.ParentMissionId)
            .IsRequired(false);
        // Dialogue relationship for Mission
        modelBuilder.Entity<Mission>()
            .HasOne(m => m.Dialogue)
            .WithOne(d => d.Mission)
            .HasForeignKey<Mission>(m => m.DialogueId)
            .IsRequired(false);

        // MissionRankRule configurations
        modelBuilder.Entity<MissionRankRule>()
            .HasOne(mrr => mrr.Mission)
            .WithMany(m => m.MissionRankRules)
            .HasForeignKey(mrr => mrr.MissionId);
        modelBuilder.Entity<MissionRankRule>()
            .HasOne(mrr => mrr.Rank)
            .WithMany(r => r.MissionRankRules)
            .HasForeignKey(mrr => mrr.RankId);

        // MissionSkillReward configurations
        modelBuilder.Entity<MissionSkillReward>()
            .HasOne(msr => msr.Mission)
            .WithMany(m => m.MissionSkillRewards)
            .HasForeignKey(msr => msr.MissionId);
        modelBuilder.Entity<MissionSkillReward>()
            .HasOne(msr => msr.Skill)
            .WithMany(s => s.MissionSkillRewards)
            .HasForeignKey(msr => msr.SkillId);

        // MissionItemReward configurations
        modelBuilder.Entity<MissionItemReward>()
            .HasOne(mir => mir.Mission)
            .WithMany(m => m.MissionItemRewards)
            .HasForeignKey(mir => mir.MissionId);

        // RankMissionRule configurations
        modelBuilder.Entity<RankMissionRule>()
            .HasOne(rmr => rmr.Rank)
            .WithMany(r => r.RankMissionRules)
            .HasForeignKey(rmr => rmr.RankId);
        modelBuilder.Entity<RankMissionRule>()
            .HasOne(rmr => rmr.Mission)
            .WithMany(m => m.RankMissionRules)
            .HasForeignKey(rmr => rmr.MissionId);

        // RankSkillRule configurations
        modelBuilder.Entity<RankSkillRule>()
            .HasOne(rsr => rsr.Rank)
            .WithMany(r => r.RankSkillRules)
            .HasForeignKey(rsr => rsr.RankId);
        modelBuilder.Entity<RankSkillRule>()
            .HasOne(rsr => rsr.Skill)
            .WithMany(s => s.RankSkillRules)
            .HasForeignKey(rsr => rsr.SkillId);

        // PlayerSkill configurations
        modelBuilder.Entity<PlayerSkill>()
            .HasOne(ps => ps.Player)
            .WithMany(p => p.PlayerSkills)
            .HasForeignKey(ps => ps.PlayerId);
        modelBuilder.Entity<PlayerSkill>()
            .HasOne(ps => ps.Skill)
            .WithMany(s => s.PlayerSkills)
            .HasForeignKey(ps => ps.SkillId);

        // PlayerMission configurations
        modelBuilder.Entity<PlayerMission>()
            .HasOne(pm => pm.Player)
            .WithMany(p => p.PlayerMissions)
            .HasForeignKey(pm => pm.PlayerId);
        modelBuilder.Entity<PlayerMission>()
            .HasOne(pm => pm.Mission)
            .WithMany(m => m.PlayerMissions)
            .HasForeignKey(pm => pm.MissionId);

        // Dialogue configurations
        modelBuilder.Entity<Dialogue>()
            .HasOne(d => d.Mission)
            .WithOne(m => m.Dialogue)
            .HasForeignKey<Dialogue>(d => d.MissionId)
            .IsRequired();

        // DialogueMessage configurations
        modelBuilder.Entity<DialogueMessage>()
            .HasOne(dm => dm.InitialDialogue)
            .WithMany()
            .HasForeignKey(dm => dm.InitialDialogueId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<DialogueMessage>()
            .HasOne(dm => dm.InterimDialogue)
            .WithMany()
            .HasForeignKey(dm => dm.InterimDialogueId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);
        modelBuilder.Entity<DialogueMessage>()
            .HasOne(dm => dm.EndDialogue)
            .WithMany()
            .HasForeignKey(dm => dm.EndDialogueId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);

        // DialogueMessageResponseOption configurations
        modelBuilder.Entity<DialogueMessageResponseOption>()
            .HasOne(dmro => dmro.ParentDialogueMessage)
            .WithMany(dm => dm.DialogueMessageResponseOptions)
            .HasForeignKey(dmro => dmro.ParentDialogueMessageId)
            .IsRequired();
        modelBuilder.Entity<DialogueMessageResponseOption>()
            .HasOne(dmro => dmro.DestinationDialogueMessage)
            .WithMany()
            .HasForeignKey(dmro => dmro.DestinationDialogueMessageId)
            .IsRequired(false)
            .OnDelete(DeleteBehavior.Restrict);
    }
}