using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data;
using System.Linq;

namespace Data.SeaHavenIndustries
{
    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        {
        }
        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);
            foreach (var foreignKey in builder.Model.GetEntityTypes().SelectMany
             (e => e.GetForeignKeys()))
            {
                foreignKey.DeleteBehavior = DeleteBehavior.Restrict;
            }

            builder.Entity<VendorAccessToken>()
                .HasIndex(t => t.Token)
                .IsUnique();

            builder.Entity<DispatchUpliftRequest>()
                .HasIndex(u => new { u.DispatchId, u.Status })
                .IsUnique()
                .HasFilter("[Status] = 'Pending'");

            builder.Entity<WorkOrderFieldLock>()
                .HasIndex(l => new { l.WorkOrderId, l.FieldName })
                .IsUnique();

            builder.Entity<WorkOrder>()
                .Property(w => w.RowVersion)
                .IsRowVersion();

            builder.Entity<WorkOrder>()
                .HasIndex(w => w.SiteCode)
                .HasFilter("[istemplate] = 0");

            builder.Entity<WorkOrder>()
                .HasIndex(w => w.InternalWONumber)
                .HasFilter("[istemplate] = 0");

            builder.Entity<WorkOrder>()
                .HasIndex(w => new { w.LifecycleStatus, w.ScheduledDate })
                .HasFilter("[istemplate] = 0");

            builder.Entity<Dispatch>()
                .Property(d => d.RowVersion)
                .IsRowVersion();

            builder.Entity<WorkOrder>()
                .HasOne(w => w.PrimaryDispatch)
                .WithMany()
                .HasForeignKey(w => w.PrimaryDispatchId)
                .OnDelete(DeleteBehavior.Restrict);
        }
        public DbSet<Category> Categories { get; set; }
        public DbSet<Locations> Locations { get; set; }
        public DbSet<Contacts> Contacts { get; set; }
        public DbSet<WorkOrder> workOrders { get; set; }
        public DbSet<Template> Templates { get; set; }
        public DbSet<Comments> Comments { get; set; }
        public DbSet<Quotes> Quotes { get; set; }
        public DbSet<QuotesLineItems> QuotesLines { get; set; }
        public DbSet<ForgetPasswordCode> ForgetPasswordCodes { get; set; }
        public DbSet<WorkOrderContacts> WorkOrderContacts { get; set; }
        public DbSet<WorkOrderCategories> workOrderCategories { get; set; }
        public DbSet<WorkOrderAttachments> workOrderAttachments { get; set; }
        public DbSet<WorkOrderAuditLog> WorkOrderAuditLogs { get; set; }
        public DbSet<WorkOrderFieldLock> WorkOrderFieldLocks { get; set; }
        public DbSet<DropdownOption> DropdownOptions { get; set; }
        public DbSet<Vendor> Vendors { get; set; }
        public DbSet<VendorAccessToken> VendorAccessTokens { get; set; }
        public DbSet<Dispatch> Dispatches { get; set; }
        public DbSet<DispatchWorkOrder> DispatchWorkOrders { get; set; }
        public DbSet<DispatchChecklistItem> DispatchChecklistItems { get; set; }
        public DbSet<DispatchSignoff> DispatchSignoffs { get; set; }
        public DbSet<DispatchUpliftRequest> DispatchUpliftRequests { get; set; }
        public DbSet<TaskListTemplate> TaskListTemplates { get; set; }
        public DbSet<TaskListTemplateItem> TaskListTemplateItems { get; set; }

        // New DbSets for added entities
        public DbSet<Accounts> Accounts { get; set; }
        public DbSet<Addresses> Addresses { get; set; }
        public DbSet<Assets> Assets { get; set; }
        public DbSet<Employee> Employees { get; set; }
        public DbSet<FollowUps> FollowUps { get; set; }
        public DbSet<PMSchedules> PMSchedules { get; set; }
        public DbSet<ContactDetails> ContactDetails { get; set; }
        public DbSet<Events> Events { get; set; }

        // Employee related DbSets
        public DbSet<EmployeeAddress> EmployeeAddresses { get; set; }
        public DbSet<EmployeePhone> EmployeePhones { get; set; }
        public DbSet<EmployeeEmail> EmployeeEmails { get; set; }
        public DbSet<Department> Departments { get; set; }
        public DbSet<JobTitle> JobTitles { get; set; }
        public DbSet<Region> Regions { get; set; }

        public override int SaveChanges()
        {
            BumpRowVersionsForInMemoryProvider();
            return base.SaveChanges();
        }

        public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
        {
            BumpRowVersionsForInMemoryProvider();
            return base.SaveChangesAsync(cancellationToken);
        }

        private void BumpRowVersionsForInMemoryProvider()
        {
            if (!Database.ProviderName?.Contains("InMemory", StringComparison.OrdinalIgnoreCase) ?? true)
                return;

            foreach (var entry in ChangeTracker.Entries<WorkOrder>())
            {
                if (entry.State == EntityState.Modified)
                    entry.Entity.RowVersion = IncrementRowVersion(entry.Entity.RowVersion);
            }

            foreach (var entry in ChangeTracker.Entries<Dispatch>())
            {
                if (entry.State == EntityState.Modified)
                    entry.Entity.RowVersion = IncrementRowVersion(entry.Entity.RowVersion);
            }
        }

        private static byte[] IncrementRowVersion(byte[]? current)
        {
            var bytes = current != null && current.Length > 0
                ? (byte[])current.Clone()
                : new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 };

            for (var i = 0; i < bytes.Length; i++)
            {
                if (++bytes[i] != 0)
                    break;
            }

            return bytes;
        }
   
    }
    public class ApplicationUser : IdentityUser
    {
        public string? FirstName { get; set; }
        public string? LastName { get; set; }
        public string? UniqueName { get; set; }
        public string? Locations { get; set; }
        public string? Contact { get; set; }
        public DateTime? CreatedDate { get; set; }
        public DateTime? DeletedDate { get; set; }
        public bool? IsDeleted { get; set; }
        public string? UserImage { get; set; }
        public string? Initials { get; set; }
        public string? Color { get; set; }
        public int? Type { get; set; } // 1 for users 0 for admin
       public ICollection<Template>? Templates { get; set; }
       public ICollection<WorkOrder>? WorkOrders { get; set; }
    }
    public class FullAuditEntity
    {
        [Key]
        public int Id { get; set; }
        public bool? IsDeleted { get; set; }
        public string? createdby { get; set; }
        public string? DeleterUserId { get; set; }
        public DateTime? DeletionTime { get; set; }
        public DateTime? CreatedDate { get; set; }
        public DateTime? LastModificationTime { get; set; }
        public int? LastModifierUserId { get; set; }

    }

}