using Manager.DTOs;
using ManagerService.Data.SubSection;
using ManagerService.DTOs;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Text.Json;
using static ManagerService.Data.SubSection.SectionEvent;

namespace ManagerService.Data
{
    public class MyInfoMateDbContext : DbContext
    {
        public MyInfoMateDbContext(DbContextOptions<MyInfoMateDbContext> options) : base(options) { }

        public DbSet<Instance> Instances { get; set; }
        public DbSet<SubscriptionPlan> SubscriptionPlans { get; set; }
        public DbSet<Configuration> Configurations { get; set; }
        public DbSet<Section> Sections { get; set; }
        public DbSet<Device> Devices { get; set; }
        public DbSet<Resource> Resources { get; set; }
        public DbSet<User> Users { get; set; }

        public DbSet<ApplicationInstance> ApplicationInstances { get; set; }
        public DbSet<AppConfigurationLink> AppConfigurationLinks { get; set; }


        // MAP
        public DbSet<GeoPoint> GeoPoints { get; set; }

        // QUIZ
        public DbSet<QuizQuestion> QuizQuestions { get; set; }

        public DbSet<GuidedPath> GuidedPaths { get; set; }
        public DbSet<GuidedStep> GuidedSteps { get; set; }

        // Events
        public DbSet<ProgrammeBlock> ProgrammeBlocks { get; set; }
        public DbSet<MapAnnotation> MapAnnotations { get; set; }

        // Agenda
        public DbSet<EventAgenda> EventAgendas { get; set; }

        // Statistics
        public DbSet<VisitEvent> VisitEvents { get; set; }

        // API Keys
        public DbSet<ApiKey> ApiKeys { get; set; }

        // Push Notifications
        public DbSet<PushNotification> PushNotifications { get; set; }


        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            };

            base.OnModelCreating(modelBuilder);

            modelBuilder.Entity<Configuration>()
            .Property(s => s.Title)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<Section>()
                .Property<string>("Discriminator")
                .HasMaxLength(50);

            modelBuilder.Entity<Section>()
                .HasDiscriminator<string>("Discriminator")
                .HasValue<Section>("Base")
                .HasValue<SectionAgenda>("Agenda")
                .HasValue<SectionArticle>("Article")
                .HasValue<SectionEvent>("Event")
                .HasValue<SectionMap>("Map")
                .HasValue<SectionMenu>("Menu")
                .HasValue<SectionPdf>("PDF")
                .HasValue<SectionGame>("Game")
                .HasValue<SectionQuiz>("Quiz")
                .HasValue<SectionSlider>("Slider")
                .HasValue<SectionVideo>("Video")
                .HasValue<SectionWeather>("Weather")
                .HasValue<SectionWeb>("Web");

            /*modelBuilder.Entity<GeoPoint>(entity =>
            {
                entity.Property(e => e.Geometry).HasColumnType("geometry");
            });

            modelBuilder.Entity<GuidedStep>(entity =>
            {
                entity.Property(e => e.Geometry).HasColumnType("geometry");
            });*/

            modelBuilder.Entity<Section>()
                .Property(s => s.Title)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<Section>()
                .Property(s => s.Description)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
                .Property(s => s.Title)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Description)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Contents)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<ContentDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Schedules)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Prices)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Phone)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Email)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GeoPoint>()
               .Property(s => s.Site)
               .HasColumnType("jsonb")
               .HasConversion(
                   v => JsonSerializer.Serialize(v, options),
                   v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            // Configurations JSON pour GuidedPath
            modelBuilder.Entity<GuidedPath>()
                .Property(gp => gp.Title)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GuidedPath>()
                .Property(gp => gp.Description)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            // Configurations JSON pour GuidedStep
            modelBuilder.Entity<GuidedStep>()
                .Property(gs => gs.Title)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GuidedStep>()
                .Property(gs => gs.Description)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<GuidedStep>()
                .Property(gp => gp.TimerExpiredMessage)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<EventAgenda>()
                .Property(s => s.Label)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<EventAgenda>()
                .Property(s => s.Description)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));

            modelBuilder.Entity<EventAgenda>()
                .Property(s => s.Address)
                .HasColumnType("jsonb")
                .HasConversion(
                    v => JsonSerializer.Serialize(v, options),
                    v => JsonSerializer.Deserialize<EventAddress>(v, options));

            // SectionEvent: link to base SectionMap
            modelBuilder.Entity<SectionEvent>()
                .HasOne(se => se.BaseMap)
                .WithMany()
                .HasForeignKey(se => se.BaseSectionMapId)
                .IsRequired(false)
                .OnDelete(DeleteBehavior.SetNull);

            // MapAnnotation: global event-level annotations linked directly to SectionEvent
            modelBuilder.Entity<MapAnnotation>()
                .HasOne<SectionEvent>()
                .WithMany(se => se.GlobalMapAnnotations)
                .HasForeignKey(ma => ma.SectionEventId)
                .IsRequired(false)
                .OnDelete(DeleteBehavior.Cascade);

            // Seed : plans d'abonnement par défaut
            modelBuilder.Entity<SubscriptionPlan>().HasData(
                new SubscriptionPlan
                {
                    Id = "plan-starter",
                    Name = "Starter",
                    StorageQuotaBytes = 1L * 1024 * 1024 * 1024,   // 1 GB
                    AiRequestsPerMonth = 0,
                },
                new SubscriptionPlan
                {
                    Id = "plan-standard",
                    Name = "Standard",
                    StorageQuotaBytes = 10L * 1024 * 1024 * 1024,  // 10 GB
                    AiRequestsPerMonth = 100,
                },
                new SubscriptionPlan
                {
                    Id = "plan-premium",
                    Name = "Premium",
                    StorageQuotaBytes = 50L * 1024 * 1024 * 1024,  // 50 GB
                    AiRequestsPerMonth = 500,
                }
            );
        }
    }
}