package com.mobizone.kb.config;

import com.mobizone.kb.entity.*;
import com.mobizone.kb.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

@Component
public class DataInitializerConfig implements CommandLineRunner {

    @Autowired
    private IUsersService usersService;

    @Autowired
    private IRolesService rolesService;

    @Autowired
    private IUserRolesService userRolesService;

    @Autowired
    private IMenuService menuService;

    @Autowired
    private IPermissionService permissionService;

    @Autowired
    private IRolePermissionService rolePermissionService;

    @Autowired
    private IRoleMenuService roleMenuService;

    @Override
    public void run(String... args) throws Exception {
        // 初始化权限
        initPermissions();

        // 初始化菜单
        initMenus();

        // 初始化角色
        initRoles();

        // 初始化管理员账号
        Long adminUserId = initAdminUser();

        // 如果成功创建了管理员账号，则分配角色
        if (adminUserId != null) {
            assignRolesToAdmin(adminUserId);
        }

        // 为超级管理员分配所有权限
        assignPermissionsToSuperAdmin();
    }

    private void initPermissions() {
        // 用户管理权限
        createPermissionIfNotExists("user:list", "用户列表", "user", "read", "查看用户列表");
        createPermissionIfNotExists("user:add", "添加用户", "user", "create", "创建新用户");
        createPermissionIfNotExists("user:edit", "编辑用户", "user", "update", "编辑用户信息");
        createPermissionIfNotExists("user:delete", "删除用户", "user", "delete", "删除用户");

        // 菜单管理权限
        createPermissionIfNotExists("menu:list", "菜单列表", "menu", "read", "查看菜单列表");
        createPermissionIfNotExists("menu:add", "添加菜单", "menu", "create", "创建新菜单");
        createPermissionIfNotExists("menu:edit", "编辑菜单", "menu", "update", "编辑菜单信息");
        createPermissionIfNotExists("menu:delete", "删除菜单", "menu", "delete", "删除菜单");

        // 角色管理权限
        createPermissionIfNotExists("role:list", "角色列表", "role", "read", "查看角色列表");
        createPermissionIfNotExists("role:add", "添加角色", "role", "create", "创建新角色");
        createPermissionIfNotExists("role:edit", "编辑角色", "role", "update", "编辑角色信息");
        createPermissionIfNotExists("role:delete", "删除角色", "role", "delete", "删除角色");

        // 权限管理权限
        createPermissionIfNotExists("permission:list", "权限列表", "permission", "read", "查看权限列表");
        createPermissionIfNotExists("permission:add", "添加权限", "permission", "create", "创建新权限");
        createPermissionIfNotExists("permission:edit", "编辑权限", "permission", "update", "编辑权限信息");
        createPermissionIfNotExists("permission:delete", "删除权限", "permission", "delete", "删除权限");
    }

    private void createPermissionIfNotExists(String code, String name, String resource, String action, String description) {
        Permission existingPermission = permissionService.getPermissionByCode(code);
        if (existingPermission == null) {
            Permission permission = new Permission();
            permission.setPermissionCode(code);
            permission.setPermissionName(name);
            permission.setResource(resource);
            permission.setAction(action);
            permission.setDescription(description);
            permission.setCreatedAt(LocalDateTime.now());
            permissionService.addPermission(permission);
        }
    }

    private void initMenus() {
        // 系统管理主菜单
        Long systemMenuId = createMenuIfNotExists("系统管理", "system", "/system", null, "system", 0L, 1, 100);

        // 用户管理菜单
        createMenuIfNotExists("用户管理", "user", "/system/user", "system/user/index", "user", systemMenuId, 1, 101);

        // 角色管理菜单
        createMenuIfNotExists("角色管理", "role", "/system/role", "system/role/index", "role", systemMenuId, 1, 102);

        // 菜单管理菜单
        createMenuIfNotExists("菜单管理", "menu", "/system/menu", "system/menu/index", "menu", systemMenuId, 1, 103);

        // 权限管理菜单
        createMenuIfNotExists("权限管理", "permission", "/system/permission", "system/permission/index", "permission", systemMenuId, 1, 104);
    }

    private Long createMenuIfNotExists(String name, String code, String path, String component,
                                       String icon, Long parentId, Integer type, Integer sort) {
        // 这里需要你实现一个根据code查询菜单的方法
        List<Menu> allMenus = menuService.getAllMenus();
        Menu existingMenu = allMenus.stream()
                .filter(menu -> code.equals(menu.getMenuCode()))
                .findFirst()
                .orElse(null);

        if (existingMenu == null) {
            Menu menu = new Menu();
            menu.setMenuName(name);
            menu.setMenuCode(code);
            menu.setPath(path);
            menu.setComponent(component);
            menu.setIcon(icon);
            menu.setParentId(parentId);
            menu.setMenuType(type);
            menu.setSortOrder(sort);
            menu.setStatus(1);
            menu.setCreatedAt(LocalDateTime.now());
            menu.setUpdatedAt(LocalDateTime.now());
            menuService.addMenu(menu);
            return menu.getId();
        }
        return existingMenu.getId();
    }

    private void initRoles() {
        if (!rolesService.roleExists("SUPER_ADMIN")) {
            Roles adminRole = new Roles();
            adminRole.setRole_name("超级管理员");
            adminRole.setRole_code("SUPER_ADMIN");
            adminRole.setDescription("超级管理员，拥有所有权限");
            rolesService.addRole(adminRole);
            System.out.println("超级管理员角色创建成功");
        }

        if (!rolesService.roleExists("ROLE_ADMIN")) {
            Roles adminRole = new Roles();
            adminRole.setRole_name("管理员");
            adminRole.setRole_code("ROLE_ADMIN");
            adminRole.setDescription("普通管理员，拥有特定权限");
            rolesService.addRole(adminRole);
            System.out.println("管理员角色创建成功");
        }

        if (!rolesService.roleExists("ROLE_USER")) {
            Roles userRole = new Roles();
            userRole.setRole_name("普通用户");
            userRole.setRole_code("ROLE_USER");
            userRole.setDescription("普通用户，拥有基本权限");
            rolesService.addRole(userRole);
            System.out.println("普通用户角色创建成功");
        }
    }

    private Long initAdminUser() {
        if (!usersService.userExists("admin")) {
            Users admin = new Users();
            admin.setUsername("admin");
            admin.setPassword("Password01!");
            admin.setNickname("系统管理员");
            admin.setCreated_by(1L);
            admin.setPhone("18521510875");
            admin.setEmail("811495111@qq.com");
            usersService.addUser(admin);
            System.out.println("管理员账号创建成功");
            return admin.getId();
        }
        return usersService.getUserByUserName("admin").getId();
    }

    private void assignRolesToAdmin(Long adminUserId) {
        Roles adminRole = rolesService.getByRoleCode("SUPER_ADMIN");
        if (!userRolesService.hasRole(adminUserId, adminRole.getId())) {
            UserRoles userRole = new UserRoles();
            userRole.setUserId(adminUserId);
            userRole.setRoleId(adminRole.getId());
            userRolesService.addUserRole(userRole);
            System.out.println("管理员角色分配成功");
        }
    }

    private void assignPermissionsToSuperAdmin() {
        Roles superAdminRole = rolesService.getByRoleCode("SUPER_ADMIN");
        if (superAdminRole != null) {
            // 获取所有权限ID
            List<Long> allPermissionIds = permissionService.getAllPermissions().stream()
                    .map(Permission::getId)
                    .collect(Collectors.toList());

            // 检查是否已经分配了权限
            List<Long> existingPermissions = rolePermissionService.getPermissionIdsByRoleId(superAdminRole.getId());
            if (existingPermissions.isEmpty() && !allPermissionIds.isEmpty()) {
                rolePermissionService.assignPermissionsToRole(superAdminRole.getId(), allPermissionIds);
                System.out.println("超级管理员权限分配成功");
            }

            // 分配菜单权限
            assignMenusToSuperAdmin(superAdminRole.getId());
        }
    }
    private void assignMenusToSuperAdmin(Long roleId) {
        // 获取所有菜单ID
        List<Long> allMenuIds = menuService.getAllMenus().stream()
                .map(Menu::getId)
                .collect(Collectors.toList());

        if (!allMenuIds.isEmpty()) {
            // 检查是否已经分配了菜单权限
            List<Long> existingMenuIds = roleMenuService.getMenuIdsByRoleId(roleId);

            if (existingMenuIds.isEmpty()) {
                // 为超级管理员分配所有菜单权限
                roleMenuService.assignMenusToRole(roleId, allMenuIds);
                System.out.println("超级管理员菜单权限分配成功，共分配 " + allMenuIds.size() + " 个菜单");
            } else {
                System.out.println("超级管理员已拥有菜单权限，跳过分配");
            }
        }
    }
}