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<EventModel> Events { get; set; }

        public DbSet<EnvironmentModel> Environments { get; set; }
        public DbSet<EnvironmentDomainsModel> EnvironmentDomains { get; set; }
        public DbSet<DomainModel> Domains { get; set; }
        public DbSet<VirtualMachineModel> VirtualMachines { get; set; }
        public DbSet<DeploymentModel> Deployments { get; set; }
        public DbSet<DeploymentGroupModel> DeploymentGroups { get; set; }
        public DbSet<TemplateModel> Templates { get; set; }
        public DbSet<DeploymentRuleModel> DeploymentRules { get; set; }
        public DbSet<DeploymentRuleStepModel> DeploymentRuleSteps { 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<JobModel> Jobs { get; set; }
        public DbSet<RunbookModel> Runbooks { 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<DeploymentModel>()
                .ToTable("DeploymentExecutions");
            modelBuilder.Entity<DeploymentModel>()
                .Property(deployment => deployment.DeploymentGroupId)
                .HasColumnName("DeploymentBatchId");

            modelBuilder.Entity<QueueJobModel>()
                .ToTable("DeploymentJobs");

            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<QueueJobStepModel>()
                .ToTable("DeploymentJobSteps");
            modelBuilder.Entity<QueueJobStepModel>()
                .Property(step => step.QueueJobId)
                .HasColumnName("DeploymentJobId");
            modelBuilder.Entity<QueueJobStepModel>()
                .Property(step => step.DependsOnQueueJobStepId)
                .HasColumnName("DependsOnDeploymentJobStepId");

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

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

            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<TemplateModel>()
                .HasOne(template => template.DeploymentRule)
                .WithMany()
                .HasForeignKey(template => template.DeploymentRuleId);

            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);
            
            modelBuilder.Entity<JobModel>()
                .HasKey(j => new { j.RunbookId, j.DeploymentId });

            modelBuilder.Entity<JobModel>()
                .HasOne(j => j.Deployment)
                .WithMany(d => d.Jobs)
                .HasPrincipalKey(d => d.Id)
                .HasForeignKey(j => j.DeploymentId);

            modelBuilder.Entity<JobModel>()
                .HasOne(j => j.Runbook)
                .WithMany(r => r.Jobs)
                .HasPrincipalKey(r => r.Id)
                .HasForeignKey(j => j.RunbookId);

            modelBuilder.Entity<EventModel>()
                .HasOne(e => e.Runbook)
                .WithMany(r => r.Events)
                .HasPrincipalKey(e => e.Id)
                .HasForeignKey(r => r.RunbookId);

            OnModelCreatingAddDefaultSqlValues(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);
                        }
                    }
                }
            }
        }
    }
}