using System.Linq.Expressions;
using System.Reflection;
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.Common.I18n;
using Pf2eModel.Model.Enum;
using Pf2eModel.Model.Structure;
using Pf2eModel.Model.Structure.AncestryRelation;
using Pf2eModel.Model.Structure.ArchetypeRelation;
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);
        DefineMethods(modelBuilder);
    }

    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 BindLocaleString<T>(
        EntityTypeBuilder<T> entity,
        Expression<Func<T, LocaleString>> func
    )
        where T : class
    {
        /*
        entity.OwnsMany(func, d =>
        {
            d.ToJson();
        });
        */

        entity
            .Property(func)
            .HasConversion(v => v.Serialize(), v => LocaleString.Deserialize(v))
            .HasColumnType("jsonb");
    }

    private void DefineEnums(ModelBuilder modelBuilder)
    {
        modelBuilder
            .HasPostgresEnum<EntityType>()
            .HasPostgresEnum<EntityRarity>()
            .HasPostgresEnum<LocaleType>()
            .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 =>
        {
            BindLocaleString(entity, e => e.Name);

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

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

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

        // 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 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)
                .WithMany(f => f.Archetypes)
                .UsingEntity<ArchetypeFeats>(
                    l => l.HasOne<Feat>().WithMany().HasForeignKey(af => af.FeatId),
                    r => r.HasOne<Archetype>().WithMany().HasForeignKey(af => af.ArchetypeId)
                );
        });

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

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

            entity
                .HasOne(g => g.Class)
                .WithMany(c => c.SubclassGroups)
                .HasForeignKey(g => g.ClassId)
                .OnDelete(DeleteBehavior.Cascade);
        });
        modelBuilder.Entity<Subclass>(entity =>
        {
            BindEntity(entity);

            BindLocaleString(entity, s => s.Additional);

            entity
                .HasOne(s => s.Group)
                .WithMany(g => g.Subclasses)
                .HasForeignKey(s => s.GroupId)
                .OnDelete(DeleteBehavior.Cascade);
        });

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

    private void DefineMethods(ModelBuilder modelBuilder)
    {
        MethodInfo localeSearch = typeof(Pf2eDbContext).GetMethod(
            nameof(LocaleSearch),
            BindingFlags.Static | BindingFlags.Public,
            [typeof(LocaleString), typeof(string)]
        )!;
        modelBuilder.HasDbFunction(
            localeSearch,
            builder =>
            {
                builder.HasName("locale_search");
                builder.HasParameter("data").HasStoreType("jsonb");
                builder.HasParameter("search_value");
            }
        );

        MethodInfo localeSearchArray = typeof(Pf2eDbContext).GetMethod(
            nameof(LocaleSearchArray),
            BindingFlags.Static | BindingFlags.Public,
            [typeof(LocaleString), typeof(IEnumerable<string>)]
        )!;
        modelBuilder.HasDbFunction(
            localeSearchArray,
            builder =>
            {
                builder.HasName("locale_search_array");
                builder.HasParameter("data").HasStoreType("jsonb");
                builder.HasParameter("search_values");
            }
        );
    }

    public static bool LocaleSearch(LocaleString data, string search_value) =>
        throw new InvalidOperationException("Only for LINQ translation");

    public static bool LocaleSearchArray(LocaleString data, IEnumerable<string> search_values) =>
        throw new InvalidOperationException("Only for LINQ translation");
}