namespace Logan.Web.DBContext
{
    public class WebDBContext : DbContext
    {
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            modelBuilder.Configurations.Add(new UserDBContext());
            modelBuilder.Configurations.Add(new RoleDBContext());
            modelBuilder.Configurations.Add(new ArticleDBContext());
            modelBuilder.Configurations.Add(new ArticleCommentDBContext());
            modelBuilder.Configurations.Add(new ForumTitleDBContext());
            modelBuilder.Configurations.Add(new ForumCategoryDBContext());
            modelBuilder.Configurations.Add(new ForumThreadDBContext());
            modelBuilder.Configurations.Add(new ForumPostDBContext());
        }
        public WebDBContext()
            : base("LoganMVC")
        {
            Database.SetInitializer<WebDBContext>(new DropCreateDatabaseAlways<WebDBContext>());
        }

        public void Seed()
        {
            if (!Roles.Any())
            {
                List<Role> roles = new List<Role>
                {
                    new Role { RoleName = "Admin" },
                    new Role { RoleName = "User" }
                };
                foreach (Role r in roles)
                {
                    Roles.Add(r);
                }
                SaveChanges();
            }
            if (!Users.Any())
            {
                User u = new User();
                u.EmailAddress = "ortund@this.com";
                u.Username = "ortund";
                u.Password = Hashing.CreateHash("S@omep455w0rD");
                u.Role = Roles.Single(r => r.RoleName == "Admin");
                u.PasswordReset = false;
                u.PasswordResetKey = Hashing.CreateKey(); // Hashing is referenced from Logan.Utilities

                Users.Add(u);
                SaveChanges();
            }
        }

        public DbSet<User> Users { get; set; }
        public DbSet<Role> Roles { get; set; }
        public DbSet<Article> Articles { get; set; }
        public DbSet<ArticleComment> ArticleComments { get; set; }
        public DbSet<ForumTitle> ForumTitles { get; set; }
        public DbSet<ForumCategory> ForumCategories { get; set; }
        public DbSet<ForumThread> ForumThreads { get; set; }
        public DbSet<ForumPost> ForumPosts { get; set; }
    }

    // LoganDBBaseObject sets Key constraints for generic columns (for PK and auditing purposes) as needed
    public class RoleDBContext : LoganDBBaseObject<Role>
    {
        private static WebDBContext db = new WebDBContext();

        public RoleDBContext()
            : base()
        {
            Property(p => p.RoleName)
                .HasColumnName("sRoleName")
                .IsRequired();

            HasMany(m => m.Users)
                .WithRequired();

            ToTable("Roles");
        }
    }

    public class UserDBContext : LoganDBBaseObject<User>
    {
        private static WebDBContext db = new WebDBContext();

        public UserDBContext()
            : base()
        {
            Property(p => p.Username)
                .HasColumnName("sUsername")
                .HasMaxLength(20)
                .IsRequired();

            Property(p => p.EmailAddress)
                .HasColumnName("sEmailAddress")
                .HasMaxLength(200)
                .IsRequired();

            Property(p => p.Password)
                .HasColumnName("sPassword")
                .HasMaxLength(255)
                .IsRequired();

            Property(p => p.Biography)
                .HasColumnName("sBiography")
                .HasColumnType("text");

            HasRequired(r => r.Role)
                .WithMany(m => m.Users)
                .Map(x => x.MapKey("fkRoleID"))
                .WillCascadeOnDelete(false);

            Property(p => p.PasswordReset)
                .HasColumnName("PasswordReset")
                .HasColumnType("bit");

            Property(p => p.PasswordResetKey)
                .HasColumnName("sPasswordResetKey");

            Property(p => p.ResetExpiry)
                .HasColumnType("datetime")
                .IsOptional();

            Property(p => p.CreatedBy)
                .HasColumnName("sCreatedBy");

            Property(p => p.CreateDate)
                .HasColumnType("datetime")
                .IsOptional();

            ToTable("Users");

        }
    }
}

namespace Logan.Web.Objects
{
    // LoganBaseObject just adds in generic columns to the tables (PK and auditing)
    public class Role : LoganBaseObject<Role>
    {
        public string RoleName { get; set; }

        public virtual ICollection<User> Users { get; set; }

        public Role()
        {
            RoleName = String.Empty;
            Users = new List<User>();
        }
    }

    public class User : LoganBaseObject<User>
    {
        public string Username { get; set; }
        public string EmailAddress { get; set; }
        public string Password { get; set; }
        public string Biography { get; set; }
        public virtual Role Role { get; set; }
        public bool PasswordReset { get; set; }
        public string PasswordResetKey { get; set; }
        public DateTime ResetExpiry { get; set; }
        public string CreatedBy { get; set; }
        public DateTime CreateDate { get; set; }

        public virtual ICollection<Article> Articles { get; set; }

        public User()
        {
            Username = String.Empty;
            EmailAddress = String.Empty;
            Password = String.Empty;
            Biography = String.Empty;
            PasswordReset = false;
            CreatedBy = String.Empty;
            Articles = new List<Article>();
        }
    }
}

namespace Logan.Web.Data
{
    public class WebUser
    {
        WebDBContext db = new WebDBContext();

        // CRUD functionality goes here
    }
}