namespace RedFood.Dal
{
    public interface IAppDbContext
    {
        DbSet<User> Users { get; }
        DbSet<Competition> Competitions { get; }
        DbSet<Question> Questions { get; }
        DbSet<Answer> Answers { get; }
        DbSet<Variant> Variants { get; }
        DbSet<UserCompetition> UserCompetitions { get; }
        Task<int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken));
        Task<ITransaction> BeginTransactionAsync();
        void UpdateRange<T>(params T[] entities) where T : class;
        void Update<TEntity>(TEntity entity) where TEntity : class;
        void RemoveEntity<TEntity>(TEntity entity) where TEntity : class;
        void RemoveRangeEntities<T>(IEnumerable<T> entities) where T : class;
    }

    public interface ITransaction : IDisposable
    {
        void CommitTransaction();
        void RollbackTransaction();
    }

    public class AppDbContext : DbContext, IAppDbContext
    {
        public DbSet<Question> Questions { get; set; }
        public DbSet<Answer> Answers { get; set; }
        public DbSet<Variant> Variants { get; set; }
        public DbSet<UserCompetition> UserCompetitions { get; set; }

        async Task<ITransaction> IAppDbContext.BeginTransactionAsync()
        {
            var transaction = await Database.BeginTransactionAsync().ConfigureAwait(false);
            return new DisposableTransaction(transaction);
        }

        public void UpdateRange<T>(params T[] entities) where T : class
        {
            foreach (var entity in entities)
            {
                Update(entity);
            }
        }

        public void Update<TEntity>(TEntity entity) where TEntity : class
        {
            base.Update(entity, GraphBehavior.SingleObject);
        }

        public void RemoveEntity<TEntity>(TEntity entity) where TEntity : class
        {
            Remove(entity);
        }

        public void RemoveRangeEntities<T>(IEnumerable<T> entities) where T : class
        {
            RemoveRange(entities);
        }

        public DbSet<User> Users { get; set; }
        public DbSet<Competition> Competitions { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            var configuration = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .Build();

            optionsBuilder.UseSqlServer(configuration["Data:DefaultConnection:ConnectionString"]);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Answer>()
                .HasKey(a => new {a.QuestionId, a.VariantId});

            modelBuilder.Entity<Question>()
                .HasOne(q => q.CorrectVariant)
                .WithOne(v => v.Question)
                .HasForeignKey<Question>(q => q.CorrectVariantId);

            modelBuilder.Entity<Variant>()
                .HasOne(v => v.Question)
                .WithMany(a => a.Variants)
                .OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity<UserCompetition>()
                .HasKey(uc => new {uc.UserId, uc.CompetitionId});

            modelBuilder.Entity<UserCompetition>()
                .HasOne(wc => wc.Competition)
                .WithMany(c => c.Users)
                .HasForeignKey(wc => wc.CompetitionId);

            modelBuilder.Entity<UserCompetition>()
                .HasOne(wc => wc.User)
                .WithMany(u => u.Competitions)
                .HasForeignKey(wc => wc.UserId);
        }

        private class DisposableTransaction : ITransaction
        {
            private readonly IRelationalTransaction _transaction;
            private bool _commited;
            private bool _disposed;

            public DisposableTransaction(IRelationalTransaction transaction)
            {
                _transaction = transaction;
            }

            public void Dispose()
            {
                if (_disposed)
                {
                    return;
                }

                _disposed = true;
                if (!_commited)
                {
                    _transaction.Rollback();
                }

                _transaction.Dispose();
            }

            public void CommitTransaction()
            {
                _commited = true;
                _transaction.Commit();
            }

            public void RollbackTransaction()
            {
                _transaction.Rollback();
            }
        }
    }
}