using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;
using Pf2eModel.Model;
using Pf2eModel.Model.Base;
using Pf2eModel.Model.Base.Keywords;
using Pf2eModel.Model.Base.Source;
using Pf2eModel.Model.Base.Targets;
using Pf2eModel.Model.Common;
using Pf2eModel.Model.Enum;
using Pf2eModel.Model.Structure;
using Pf2eModel.Model.Structure.AncestryRelation;
using Pf2eModel.Model.Structure.BackgroundRelation;
using Pf2eModel.Model.Structure.ClassRelation;
using Pf2eModel.Model.Structure.DeityRelation;
using Pf2eModel.Model.Structure.FeatRelation;
using Pf2eModel.Model.Structure.SpellRelation;

namespace Pf2eModel;

public partial class Pf2eDbContext
{
    public const int NameLength = 255;

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

        DefineEnums(modelBuilder);
        DefineBase(modelBuilder);
        DefineCommon(modelBuilder);
        DefineStructure(modelBuilder);
    }

    private void DefineEnums(ModelBuilder modelBuilder)
    {
        modelBuilder
            .HasPostgresEnum<EntityType>()
            .HasPostgresEnum<EntityRarity>()
            .HasPostgresEnum<AliasType>()
            .HasPostgresEnum<TraitType>()
            .HasPostgresEnum<ActionCategory>()
            .HasPostgresEnum<Size>()
            .HasPostgresEnum<AncestryVision>()
            .HasPostgresEnum<ClassProgressionType>()
            .HasPostgresEnum<ConditionGroup>()
            .HasPostgresEnum<DeityCategory>()
            .HasPostgresEnum<DeityFonts>()
            .HasPostgresEnum<DeitySanctification>()
            .HasPostgresEnum<FeatActionType>()
            .HasPostgresEnum<FeatCategory>()
            .HasPostgresEnum<SpellAreaType>()
            .HasPostgresEnum<SpellDamageCategory>()
            .HasPostgresEnum<SpellDamageKinds>()
            .HasPostgresEnum<AttributeValues>()
            .HasPostgresEnum<TrainingStage>()
            .HasPostgresEnum<SourceCategory>()
            ;
    }

    private void DefineBase(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Entity>(entity =>
        {
            entity.HasMany(e => e.Traits).WithMany(t => t.Entities);

            entity.HasMany(e => e.Keywords).WithMany(t => t.Entities);

            // EntityAlias
            entity.HasMany(e => e.Aliases).WithOne(e => e.Entity)
                .HasForeignKey(e => e.EntityId)
                .OnDelete(DeleteBehavior.Cascade);

            // EntitySource
            entity.HasMany(e => e.Sources).WithOne(e => e.Entity)
                .HasForeignKey(e => e.EntityId)
                .OnDelete(DeleteBehavior.Cascade);

            // EntityExternal
            entity.HasMany(e => e.Externals).WithOne(e => e.Entity)
                .HasForeignKey(e => e.EntityId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<EntityAlias>(entity => { });

        // Source
        modelBuilder.Entity<Source>(entity =>
        {
            entity.Property(e => e.Id).HasColumnName("id");

            entity.HasMany(s => s.EntitySources).WithOne(e => e.Source)
                .HasForeignKey(e => e.SourceId)
                .OnDelete(DeleteBehavior.Cascade);

            // + EntitySource
        });
        modelBuilder.Entity<EntitySource>(entity => { });

        // External
        modelBuilder.Entity<ExternalTarget>(entity =>
        {
            entity.HasMany(t => t.EntityExternals).WithOne(e => e.Target)
                .HasForeignKey(e => e.TargetId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<EntityExternal>(entity => { });

        // Keywords
        modelBuilder.Entity<Keyword>(entity =>
        {
            entity.HasMany(e => e.Aliases).WithOne(e => e.Keyword)
                .HasForeignKey(e => e.KeywordId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<KeywordAlias>(entity => { });
    }

    private void DefineCommon(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Frequency>(entity => { });

        modelBuilder.Entity<Language>(entity => { });

        modelBuilder.Entity<Training>(entity => { });
    }

    private void BindEntity<T>(EntityTypeBuilder<T> entity) where T : class, IEntity
    {
        entity.HasOne(entity => entity.Entity)
            .WithOne()
            .HasForeignKey<T>(entity => entity.Id)
            .IsRequired();
    }

    private void DefineStructure(ModelBuilder modelBuilder)
    {
        // Action
        modelBuilder.Entity<Model.Structure.Action>(entity =>
        {
            BindEntity(entity);
        });

        // Ancestry
        modelBuilder.Entity<Ancestry>(entity =>
        {
            BindEntity(entity);

            entity.HasMany(e => e.AncestryBoosts).WithOne(e => e.Ancestry)
                .HasForeignKey(e => e.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.AncestryItems).WithOne(e => e.Ancestry)
                .HasForeignKey(e => e.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.AncestryLanguages).WithOne(e => e.Ancestry)
                .HasForeignKey(e => e.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<AncestryBoost>(entity => { });
        modelBuilder.Entity<AncestryItem>(entity =>
        {
            entity.HasOne(d => d.Item).WithMany()
                .HasForeignKey(d => d.ItemId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<AncestryLanguage>(entity =>
        {
            entity.HasOne(d => d.Language).WithMany()
                .HasForeignKey(d => d.LanguageId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Archetype
        modelBuilder.Entity<Archetype>(entity =>
        {
            BindEntity(entity);

            entity.HasOne(a => a.DedicationFeat).WithOne()
                .HasForeignKey<Archetype>(a => a.DedicationFeatId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(a => a.Feats).WithOne(f => f.Archetype)
                .HasForeignKey(f => f.ArchetypeId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Background
        modelBuilder.Entity<Background>(entity =>
        {
            BindEntity(entity);
        });
        modelBuilder.Entity<BackgroundBoost>(entity =>
        {
            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundBoosts)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<BackgroundItem>(entity =>
        {
            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundItems)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<BackgroundTraining>(entity =>
        {
            entity.HasOne(d => d.Background).WithMany(p => p.BackgroundSkills)
                .HasForeignKey(d => d.BackgroundId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Class
        modelBuilder.Entity<Class>(entity =>
        {
            BindEntity(entity);
        });
        modelBuilder.Entity<ClassKeyAbility>(entity =>
        {
            entity.HasOne(d => d.Class).WithMany(p => p.ClassKeyAbilities)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<ClassProgression>(entity =>
        {
            entity.HasOne(d => d.Class).WithMany(p => p.ClassProgressions)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Entity).WithMany()
                .HasForeignKey(d => d.EntityId)
                .OnDelete(DeleteBehavior.SetNull);
        });
        modelBuilder.Entity<ClassTraining>(entity =>
        {
            entity.HasOne(d => d.Class).WithMany(p => p.ClassTrainings)
                .HasForeignKey(d => d.ClassId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasOne(d => d.Training).WithMany()
                .HasForeignKey(d => d.TrainingId)
                .OnDelete(DeleteBehavior.SetNull);
        });

        // Condition
        modelBuilder.Entity<Condition>(entity =>
        {
            BindEntity(entity);
        });

        // Deity
        modelBuilder.Entity<Deity>(entity =>
        {
            BindEntity(entity);

            entity.HasMany(e => e.DeityAttributes).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.DeityDomains).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.DeitySpells).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.DeityWeapons).WithOne(e => e.Deity)
                .HasForeignKey(e => e.DeityId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.Skills).WithMany();
        });
        modelBuilder.Entity<DeityAttribute>(entity => { });
        modelBuilder.Entity<DeityDomain>(entity => { });
        modelBuilder.Entity<DeitySpell>(entity =>
        {
            entity.HasOne(d => d.Spell).WithMany()
                .HasForeignKey(d => d.SpellId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<DeityWeapon>(entity => { });

        // Feat
        modelBuilder.Entity<Feat>(entity =>
        {
            BindEntity(entity);

            entity.HasMany(e => e.FeatPrerequisites).WithOne(e => e.Feat)
                .HasForeignKey(e => e.FeatId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<FeatPrerequisite>(entity => { });

        // Heritage
        modelBuilder.Entity<Heritage>(entity =>
        {
            BindEntity(entity);

            entity.HasOne(d => d.Ancestry).WithMany(p => p.Heritages)
                .HasForeignKey(d => d.AncestryId)
                .OnDelete(DeleteBehavior.Cascade);
        });

        // Spell
        modelBuilder.Entity<Spell>(entity =>
        {
            BindEntity(entity);

            entity.HasOne(e => e.SpellArea).WithOne(e => e.Spell)
                .HasForeignKey<SpellArea>(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade)
                .IsRequired(false);

            entity.HasOne(e => e.SpellRitual).WithOne(e => e.Spell)
                .HasForeignKey<SpellRitual>(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade)
                .IsRequired(false);

            entity.HasMany(e => e.SpellDamages).WithOne(e => e.Spell)
                .HasForeignKey(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade);

            entity.HasMany(e => e.SpellDefenses).WithOne(e => e.Spell)
                .HasForeignKey(e => e.SpellId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<SpellArea>(entity => { });
        modelBuilder.Entity<SpellDamage>(entity => { });
        modelBuilder.Entity<SpellDefense>(entity => { });
        modelBuilder.Entity<SpellRitual>(entity => { });

        // Trait
        modelBuilder.Entity<Trait>(entity =>
        {
            BindEntity(entity);
        });
    }
}