using Lada.Framework.Data.Domains.Identity;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;

namespace Ladaer.BackEnd.Infrastructures.Services.Identity
{
    /// <summary>
    /// Service for migrating from old role naming convention to new Controller.Action pattern
    /// </summary>
    public class RoleMigrationService : IRoleMigrationService
    {
        private readonly RoleManager<Role> _roleManager;
        private readonly UserManager<User> _userManager;
        private readonly IPermissionService _permissionService;

        public RoleMigrationService(
            RoleManager<Role> roleManager,
            UserManager<User> userManager,
            IPermissionService permissionService)
        {
            _roleManager = roleManager;
            _userManager = userManager;
            _permissionService = permissionService;
        }

        public Dictionary<string, string> GetNewRolesToCreate()
        {
            return new Dictionary<string, string>
            {
                // System Roles
                { "System.Permission.Manage", "Quản lý Permission Groups" },
                { "System.Role.Manage", "Quản lý Roles" },
                { "System.User.Manage", "Quản lý Users" },

                // Agency Roles
                { "Agency.View", "Xem thông tin đại lý" },
                { "Agency.Create", "Tạo đại lý mới" },
                { "Agency.Update", "Cập nhật thông tin đại lý" },
                { "Agency.Delete", "Xóa đại lý" },

                // User Roles
                { "User.View", "Xem thông tin người dùng" },
                { "User.Create", "Tạo người dùng mới" },
                { "User.Update", "Cập nhật thông tin người dùng" },
                { "User.Delete", "Xóa người dùng" },
                { "User.Search", "Tìm kiếm người dùng" },
                { "User.SearchStaff", "Tìm kiếm nhân viên" },

                // Order Roles
                { "Order.View", "Xem đơn hàng" },
                { "Order.Create", "Tạo đơn hàng mới" },
                { "Order.Update", "Cập nhật đơn hàng" },
                { "Order.Delete", "Xóa đơn hàng" },
                { "Order.Search", "Tìm kiếm đơn hàng" },
                { "Order.Export", "Xuất dữ liệu đơn hàng" },

                // Customer Roles
                { "Customer.View", "Xem thông tin khách hàng" },
                { "Customer.Create", "Tạo khách hàng mới" },
                { "Customer.Update", "Cập nhật thông tin khách hàng" },
                { "Customer.Delete", "Xóa khách hàng" },

                // Product Roles
                { "Product.View", "Xem sản phẩm" },
                { "Product.Create", "Tạo sản phẩm mới" },
                { "Product.Update", "Cập nhật sản phẩm" },
                { "Product.Delete", "Xóa sản phẩm" },

                // Post Roles
                { "Post.View", "Xem bài viết" },
                { "Post.Create", "Tạo bài viết mới" },
                { "Post.Update", "Cập nhật bài viết" },
                { "Post.Delete", "Xóa bài viết" },

                // Candidate Roles
                { "Candidate.View", "Xem thông tin ứng viên" },
                { "Candidate.Create", "Tạo hồ sơ ứng viên" },
                { "Candidate.Update", "Cập nhật thông tin ứng viên" },
                { "Candidate.Delete", "Xóa hồ sơ ứng viên" },

                // Lead Roles
                { "Lead.View", "Xem lead" },
                { "Lead.Create", "Tạo lead mới" },
                { "Lead.Update", "Cập nhật lead" },
                { "Lead.Delete", "Xóa lead" },

                // Deploy Roles
                { "Deploy.View", "Xem thông tin triển khai" },
                { "Deploy.Manage", "Quản lý triển khai" },

                // OrderFin Roles
                { "OrderFin.View", "Xem tài chính đơn hàng" },
                { "OrderFin.Manage", "Quản lý tài chính đơn hàng" },

                // Role Management
                { "Role.View", "Xem danh sách roles" },
                { "Role.GetRoles", "Lấy danh sách roles" },

                // Report Roles
                { "Report.View", "Xem báo cáo" },
                { "Report.Export", "Xuất báo cáo" }
            };
        }

        public Dictionary<string, string> GetOldRoleToPermissionMapping()
        {
            return new Dictionary<string, string>
            {
                { "Founder", "Founder Permission" },
                { "Co-Founder", "Co-Founder Permission" },
                { "Admin", "Admin Permission" },
                { "HR", "HR Permission" },
                { "Sales", "Sales Permission" },
                { "Driver", "Driver Permission" },
                { "Accountant", "Accountant Permission" },
                { "Marketing", "Marketing Permission" },
                { "Coordinator", "Coordinator Permission" }
            };
        }

        public async Task<List<string>> CreateNewRolesAsync()
        {
            var createdRoles = new List<string>();
            var rolesToCreate = GetNewRolesToCreate();

            foreach (var (roleName, description) in rolesToCreate)
            {
                var existingRole = await _roleManager.FindByNameAsync(roleName);
                if (existingRole == null)
                {
                    var newRole = new Role
                    {
                        Name = roleName,
                        Description = description,
                        CreatedTime = DateTimeOffset.UtcNow,
                        UpdatedTime = DateTimeOffset.UtcNow
                    };

                    var result = await _roleManager.CreateAsync(newRole);
                    if (result.Succeeded)
                    {
                        createdRoles.Add(roleName);
                    }
                }
            }

            return createdRoles;
        }

        public async Task<List<string>> CreateDefaultPermissionGroupsAsync()
        {
            var createdPermissions = new List<string>();

            // Founder Permission - có tất cả quyền
            var founderRoles = GetNewRolesToCreate().Keys.ToList();
            var founderRoleIds = await GetRoleIdsByNamesAsync(founderRoles);
            var founderPermission = await _permissionService.CreatePermissionAsync(
                "Founder Permission", 
                "Quyền cao nhất - có tất cả quyền trong hệ thống", 
                founderRoleIds);
            createdPermissions.Add(founderPermission.Name);

            // Admin Permission
            var adminRoles = new List<string>
            {
                "System.Permission.Manage", "System.Role.Manage", "System.User.Manage",
                "Agency.View", "Agency.Create", "Agency.Update", "Agency.Delete",
                "User.View", "User.Create", "User.Update", "User.Delete", "User.Search", "User.SearchStaff",
                "Order.View", "Order.Create", "Order.Update", "Order.Search", "Order.Export",
                "Customer.View", "Customer.Create", "Customer.Update", "Customer.Delete",
                "Role.View", "Role.GetRoles", "Report.View", "Report.Export"
            };
            var adminRoleIds = await GetRoleIdsByNamesAsync(adminRoles);
            var adminPermission = await _permissionService.CreatePermissionAsync(
                "Admin Permission", 
                "Quyền quản trị - quản lý hệ thống và người dùng", 
                adminRoleIds);
            createdPermissions.Add(adminPermission.Name);

            // HR Permission
            var hrRoles = new List<string>
            {
                "User.View", "User.Create", "User.Update", "User.SearchStaff",
                "Candidate.View", "Candidate.Create", "Candidate.Update", "Candidate.Delete",
                "Role.View", "Role.GetRoles"
            };
            var hrRoleIds = await GetRoleIdsByNamesAsync(hrRoles);
            var hrPermission = await _permissionService.CreatePermissionAsync(
                "HR Permission", 
                "Quyền nhân sự - quản lý nhân viên và ứng viên", 
                hrRoleIds);
            createdPermissions.Add(hrPermission.Name);

            // Sales Permission
            var salesRoles = new List<string>
            {
                "Customer.View", "Customer.Create", "Customer.Update", "Customer.Delete",
                "Lead.View", "Lead.Create", "Lead.Update", "Lead.Delete",
                "Order.View", "Order.Create", "Order.Update", "Order.Search",
                "User.View"
            };
            var salesRoleIds = await GetRoleIdsByNamesAsync(salesRoles);
            var salesPermission = await _permissionService.CreatePermissionAsync(
                "Sales Permission", 
                "Quyền bán hàng - quản lý khách hàng và đơn hàng", 
                salesRoleIds);
            createdPermissions.Add(salesPermission.Name);

            // Driver Permission
            var driverRoles = new List<string>
            {
                "Order.View", "User.View"
            };
            var driverRoleIds = await GetRoleIdsByNamesAsync(driverRoles);
            var driverPermission = await _permissionService.CreatePermissionAsync(
                "Driver Permission", 
                "Quyền tài xế - xem đơn hàng và thông tin cá nhân", 
                driverRoleIds);
            createdPermissions.Add(driverPermission.Name);

            // Accountant Permission
            var accountantRoles = new List<string>
            {
                "OrderFin.View", "OrderFin.Manage",
                "Order.View", "Order.Search",
                "Report.View", "Report.Export"
            };
            var accountantRoleIds = await GetRoleIdsByNamesAsync(accountantRoles);
            var accountantPermission = await _permissionService.CreatePermissionAsync(
                "Accountant Permission", 
                "Quyền kế toán - quản lý tài chính và báo cáo", 
                accountantRoleIds);
            createdPermissions.Add(accountantPermission.Name);

            return createdPermissions;
        }

        private async Task<List<int>> GetRoleIdsByNamesAsync(List<string> roleNames)
        {
            var roleIds = new List<int>();
            foreach (var roleName in roleNames)
            {
                var role = await _roleManager.FindByNameAsync(roleName);
                if (role != null)
                {
                    roleIds.Add(role.Id);
                }
            }
            return roleIds;
        }

        public async Task<int> MigrateUsersToPermissionGroupsAsync()
        {
            var migratedCount = 0;
            var oldRoleMapping = GetOldRoleToPermissionMapping();

            foreach (var (oldRole, permissionName) in oldRoleMapping)
            {
                var usersInOldRole = await _userManager.GetUsersInRoleAsync(oldRole);
                var permission = (await _permissionService.GetAllPermissionsAsync())
                    .FirstOrDefault(p => p.Name == permissionName);

                if (permission != null)
                {
                    foreach (var user in usersInOldRole)
                    {
                        // Chỉ gán Permission nếu user chưa có Permission nào
                        if (user.PermissionId == null)
                        {
                            await _permissionService.AssignPermissionToUserAsync(user.Id, permission.Id);
                            migratedCount++;
                        }
                    }
                }
            }

            return migratedCount;
        }

        public async Task<bool> IsMigrationCompletedAsync()
        {
            // Kiểm tra xem đã có Permission Groups chưa
            var permissions = await _permissionService.GetAllPermissionsAsync();
            if (!permissions.Any()) return false;

            // Kiểm tra xem đã có Role mới chưa
            var newRoles = GetNewRolesToCreate().Keys;
            foreach (var roleName in newRoles.Take(5)) // Kiểm tra một vài role đầu tiên
            {
                var role = await _roleManager.FindByNameAsync(roleName);
                if (role == null) return false;
            }

            return true;
        }

        public async Task<MigrationResult> RunFullMigrationAsync()
        {
            var result = new MigrationResult();

            try
            {
                // 1. Tạo các Role mới
                result.CreatedRoles = await CreateNewRolesAsync();

                // 2. Tạo Permission Groups
                result.CreatedPermissions = await CreateDefaultPermissionGroupsAsync();

                // 3. Migration Users
                result.MigratedUsers = await MigrateUsersToPermissionGroupsAsync();

                result.Success = true;
                result.Message = $"Migration completed successfully. Created {result.CreatedRoles.Count} roles, {result.CreatedPermissions.Count} permissions, migrated {result.MigratedUsers} users.";
            }
            catch (Exception ex)
            {
                result.Success = false;
                result.Errors.Add(ex.Message);
                result.Message = "Migration failed: " + ex.Message;
            }

            return result;
        }
    }
}
