using Microsoft.EntityFrameworkCore;
using Microsoft.SelfService.Portal.Core.API.Extensions.Dataannotations;
using Microsoft.SelfService.Portal.Core.API.Models;
using System.Reflection;

namespace Microsoft.SelfService.Portal.Core.API.Context
{
    public class DataContext : DbContext
    {
        public DataContext(DbContextOptions<DataContext> options) : base(options)
        {
        }

        public DbSet<EnvironmentModel> Environments { get; set; }
        public DbSet<EnvironmentDomainsModel> EnvironmentDomains { get; set; }
        public DbSet<DomainModel> Domains { get; set; }
        public DbSet<TargetModel> Targets { get; set; }
        public DbSet<DeploymentModel> Deployments { get; set; }
        public DbSet<DeploymentGroupModel> DeploymentGroups { get; set; }
        public DbSet<TemplateModel> Templates { get; set; }
        public DbSet<TemplateVersionModel> TemplateVersions { get; set; }
        public DbSet<DeploymentRuleModel> DeploymentRules { get; set; }
        public DbSet<DeploymentRuleStepModel> DeploymentRuleSteps { get; set; }
        public DbSet<DeploymentTemplateSelectionModel> DeploymentTemplateSelections { get; set; }
        public DbSet<DeploymentParameterValueModel> DeploymentParameterValues { get; set; }
        public DbSet<DeploymentTargetAssignmentModel> DeploymentTargetAssignments { get; set; }
        public DbSet<TemplateCategoryModel> TemplateCategories { get; set; }
        public DbSet<ServiceModel> Services { get; set; }
        public DbSet<ServiceRoleDefinitionModel> ServiceRoleDefinitions { get; set; }
        public DbSet<TemplateOptionModel> TemplateOptions { get; set; }
        public DbSet<OptionModel> Options { get; set; }
        public DbSet<OptionCategoryModel> OptionCategories { get; set; }                
        public DbSet<QueueJobModel> QueueJobs { get; set; }
        public DbSet<QueueJobTargetModel> QueueJobTargets { get; set; }
        public DbSet<QueueJobStepModel> QueueJobSteps { get; set; }

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

            modelBuilder.Entity<EnvironmentDomainsModel>()
                 .HasKey(ed => new { ed.EnvironmentId, ed.DomainId });

            modelBuilder.Entity<EnvironmentDomainsModel>()
                .HasOne(ed => ed.Environment)
                .WithMany(e => e.EnvironmentDomains)
                .HasForeignKey(ed => ed.EnvironmentId);

            modelBuilder.Entity<EnvironmentDomainsModel>()
                .HasOne(ed => ed.Domain)
                .WithMany(d => d.EnvironmentDomains) 
                .HasForeignKey(ed => ed.DomainId);

            modelBuilder.Entity<TemplateOptionModel>()
                .HasKey(to => new { to.OptionId, to.TemplateId });

            modelBuilder.Entity<TemplateOptionModel>()
                .HasOne(to => to.Option)
                .WithMany(o => o.TemplateOptions)
                .HasForeignKey(to => to.OptionId);

            modelBuilder.Entity<TemplateOptionModel>()
                .HasOne(to => to.Template)
                .WithMany(t => t.TemplateOptions)
                .HasForeignKey(to => to.TemplateId);

            modelBuilder.Entity<TemplateCategoryModel>()
                .HasOne(tc => tc.Service)
                .WithMany(s => s.TemplateCategories)
                .HasForeignKey(tc => tc.ServiceId);

            modelBuilder.Entity<ServiceRoleDefinitionModel>()
                .HasOne(role => role.Service)
                .WithMany(service => service.RoleDefinitions)
                .HasForeignKey(role => role.ServiceId);

            modelBuilder.Entity<DeploymentGroupModel>()
                .ToTable("DeploymentBatches");

            modelBuilder.Entity<TargetModel>()
                .Property(target => target.TargetType)
                .HasMaxLength(64);

            modelBuilder.Entity<TargetModel>()
                .Property(target => target.ProviderType)
                .HasMaxLength(64);

            modelBuilder.Entity<DeploymentModel>()
                .ToTable("DeploymentExecutions");
            modelBuilder.Entity<DeploymentModel>()
                .Property(deployment => deployment.DeploymentGroupId)
                .HasColumnName("DeploymentBatchId");

            modelBuilder.Entity<QueueJobModel>()
                .ToTable("DeploymentJobs");
            modelBuilder.Entity<QueueJobModel>()
                .HasIndex(job => new { job.Status, job.ScheduledAt, job.LockedUntil, job.Priority, job.Created });
            modelBuilder.Entity<QueueJobModel>()
                .HasIndex(job => job.CorrelationId);
            modelBuilder.Entity<QueueJobModel>()
                .HasIndex(job => job.WorkerName);
            modelBuilder.Entity<QueueJobModel>()
                .Property(job => job.CorrelationId)
                .HasDefaultValueSql("NEWID()");
            modelBuilder.Entity<QueueJobModel>()
                .Property(job => job.Priority)
                .HasDefaultValue(100);
            modelBuilder.Entity<QueueJobModel>()
                .Property(job => job.RowVersion)
                .IsRowVersion();

            modelBuilder.Entity<QueueJobTargetModel>()
                .ToTable("DeploymentJobTargets");
            modelBuilder.Entity<QueueJobTargetModel>()
                .Property(target => target.QueueJobId)
                .HasColumnName("DeploymentJobId");
            modelBuilder.Entity<QueueJobTargetModel>()
                .Property(target => target.DeploymentGroupId)
                .HasColumnName("DeploymentBatchId");
            modelBuilder.Entity<QueueJobTargetModel>()
                .HasIndex(target => new { target.QueueJobId, target.Status });
            modelBuilder.Entity<QueueJobTargetModel>()
                .ToTable(table => table.HasCheckConstraint("CK_DeploymentJobTargets_OutputMetadataJson_IsJson", "[OutputMetadataJson] IS NULL OR ISJSON([OutputMetadataJson]) = 1"));

            modelBuilder.Entity<QueueJobStepModel>()
                .ToTable("DeploymentJobSteps");
            modelBuilder.Entity<QueueJobStepModel>()
                .Property(step => step.QueueJobId)
                .HasColumnName("DeploymentJobId");
            modelBuilder.Entity<QueueJobStepModel>()
                .Property(step => step.DependsOnQueueJobStepId)
                .HasColumnName("DependsOnDeploymentJobStepId");
            modelBuilder.Entity<QueueJobStepModel>()
                .HasIndex(step => new { step.QueueJobId, step.Status, step.SortOrder });
            modelBuilder.Entity<QueueJobStepModel>()
                .ToTable(table => table.HasCheckConstraint("CK_DeploymentJobSteps_OutputMetadataJson_IsJson", "[OutputMetadataJson] IS NULL OR ISJSON([OutputMetadataJson]) = 1"));

            modelBuilder.Entity<DeploymentModel>()
                .HasKey(d => new { d.TargetId, d.DeploymentGroupId });

            modelBuilder.Entity<DeploymentModel>()
                .HasOne(d => d.Target)
                .WithMany(vm => vm.Deployments)
                .HasForeignKey(d => d.TargetId);

            modelBuilder.Entity<DeploymentModel>()
                .HasOne(d => d.DeploymentGroup)
                .WithMany(dg => dg.Deployments)
                .HasForeignKey(d => d.DeploymentGroupId);

            modelBuilder.Entity<DeploymentGroupModel>()
                .HasOne(dg => dg.Template)
                .WithMany(t => t.DeploymentGroups)
                .HasForeignKey(dg => dg.TemplateId);

            modelBuilder.Entity<DeploymentGroupModel>()
                .HasOne(dg => dg.DeploymentRule)
                .WithMany()
                .HasForeignKey(dg => dg.DeploymentRuleId)
                .OnDelete(DeleteBehavior.SetNull);

            modelBuilder.Entity<DeploymentTemplateSelectionModel>()
                .HasOne(selection => selection.DeploymentGroup)
                .WithMany(batch => batch.TemplateSelections)
                .HasForeignKey(selection => selection.DeploymentGroupId);

            modelBuilder.Entity<DeploymentTemplateSelectionModel>()
                .HasOne(selection => selection.TemplateVersion)
                .WithMany()
                .HasForeignKey(selection => selection.TemplateVersionId)
                .OnDelete(DeleteBehavior.Restrict);

            modelBuilder.Entity<DeploymentTemplateSelectionModel>()
                .HasIndex(selection => new { selection.DeploymentGroupId, selection.SortOrder })
                .IsUnique();

            modelBuilder.Entity<DeploymentParameterValueModel>()
                .HasOne(parameterValue => parameterValue.DeploymentGroup)
                .WithMany(batch => batch.ParameterValues)
                .HasForeignKey(parameterValue => parameterValue.DeploymentGroupId);

            modelBuilder.Entity<DeploymentParameterValueModel>()
                .HasOne(parameterValue => parameterValue.DeploymentTemplateSelection)
                .WithMany()
                .HasForeignKey(parameterValue => parameterValue.DeploymentTemplateSelectionId)
                .OnDelete(DeleteBehavior.NoAction);

            modelBuilder.Entity<DeploymentParameterValueModel>()
                .HasIndex(parameterValue => new { parameterValue.DeploymentGroupId, parameterValue.DeploymentTemplateSelectionId, parameterValue.Name })
                .IsUnique()
                .HasFilter("[DeploymentTemplateSelectionId] IS NOT NULL");

            modelBuilder.Entity<DeploymentParameterValueModel>()
                .HasIndex(parameterValue => new { parameterValue.DeploymentGroupId, parameterValue.Name })
                .IsUnique()
                .HasFilter("[DeploymentTemplateSelectionId] IS NULL");

            modelBuilder.Entity<DeploymentParameterValueModel>()
                .ToTable(table => table.HasCheckConstraint("CK_DeploymentParameterValues_ValueJson_IsJson", "ISJSON([ValueJson]) = 1"));

            modelBuilder.Entity<DeploymentTargetAssignmentModel>()
                .HasOne(target => target.DeploymentGroup)
                .WithMany(batch => batch.TargetAssignments)
                .HasForeignKey(target => target.DeploymentGroupId);

            modelBuilder.Entity<DeploymentTargetAssignmentModel>()
                .HasOne(target => target.Target)
                .WithMany()
                .HasForeignKey(target => target.TargetId)
                .OnDelete(DeleteBehavior.Restrict);

            modelBuilder.Entity<DeploymentTargetAssignmentModel>()
                .HasIndex(target => new { target.DeploymentGroupId, target.TargetId, target.RoleKey })
                .IsUnique();

            modelBuilder.Entity<DeploymentTargetAssignmentModel>()
                .ToTable(table => table.HasCheckConstraint("CK_DeploymentTargetAssignments_NodeDataJson_IsJson", "ISJSON([NodeDataJson]) = 1"));

            modelBuilder.Entity<TemplateModel>()
                .HasOne(template => template.DeploymentRule)
                .WithMany()
                .HasForeignKey(template => template.DeploymentRuleId);

            modelBuilder.Entity<TemplateVersionModel>()
                .HasOne(version => version.Template)
                .WithMany(template => template.TemplateVersions)
                .HasForeignKey(version => version.TemplateId);

            modelBuilder.Entity<TemplateVersionModel>()
                .HasIndex(version => new { version.TemplateId, version.Version })
                .IsUnique();

            modelBuilder.Entity<TemplateVersionModel>()
                .HasIndex(version => version.TemplateId)
                .IsUnique()
                .HasFilter("[IsPublished] = 1");

            modelBuilder.Entity<TemplateVersionModel>()
                .Property(version => version.Version)
                .HasMaxLength(64);

            modelBuilder.Entity<TemplateVersionModel>()
                .Property(version => version.JsonHash)
                .HasMaxLength(64);

            modelBuilder.Entity<TemplateVersionModel>()
                .Property(version => version.SchemaVersion)
                .HasMaxLength(32);

            modelBuilder.Entity<TemplateVersionModel>()
                .ToTable(table => table.HasCheckConstraint("CK_TemplateVersions_JsonData_IsJson", "ISJSON([JsonData]) = 1"));

            modelBuilder.Entity<DeploymentRuleStepModel>()
                .HasOne(step => step.DeploymentRule)
                .WithMany(rule => rule.Steps)
                .HasForeignKey(step => step.DeploymentRuleId);

            modelBuilder.Entity<QueueJobTargetModel>()
                .HasOne(target => target.QueueJob)
                .WithMany(job => job.Targets)
                .HasForeignKey(target => target.QueueJobId);

            modelBuilder.Entity<QueueJobStepModel>()
                .HasOne(step => step.QueueJob)
                .WithMany(job => job.Steps)
                .HasForeignKey(step => step.QueueJobId);

            modelBuilder.Entity<QueueJobStepModel>()
                .HasOne(step => step.DependsOnQueueJobStep)
                .WithMany()
                .HasForeignKey(step => step.DependsOnQueueJobStepId)
                .OnDelete(DeleteBehavior.Restrict);
            
            OnModelCreatingAddDefaultSqlValues(modelBuilder);
            DemoData.Seed(modelBuilder);
        }

        private void OnModelCreatingAddDefaultSqlValues(ModelBuilder modelBuilder)
        {
            var assemblyName = "Microsoft.SelfService.Portal.Core.API";
            var nameSpace = "Microsoft.SelfService.Portal.Core.API.Models";

            var asm = Assembly.Load(assemblyName);

            List<Type> types = asm.GetTypes().Where(p => p.Namespace == nameSpace).ToList();
            var dbSets = typeof(DataContext).GetProperties().Where(p => p.PropertyType.Name.ToLower().Contains("dbset")).ToList();
            List<Type> dbSetTypes = new List<Type>();

            foreach (PropertyInfo pi in dbSets)
            {
                dbSetTypes.Add(pi.PropertyType.GetGenericArguments()[0]);
            }

            foreach (Type t in types)
            {
                if (typeof(BaseModel).IsAssignableFrom(t) && t.Name != nameof(BaseModel) && dbSetTypes.Contains(t))
                {
                    var properties = t.GetProperties().ToList();
                    foreach (var p in properties)
                    {
                        var att = p.GetCustomAttribute<DefaultValueSqlAttribute>();
                        if (att != null)
                        {
                            modelBuilder.Entity(t).Property(p.Name).HasDefaultValueSql(att.DefaultValueSql);
                        }
                    }
                }
            }
        }
    }
}