package com.example.demo.service;

import com.example.demo.model.Role;
import jakarta.annotation.PostConstruct;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;

/**
 * 角色管理服务。
 * 使用内存假数据实现角色增删改查、权限分配（含超级管理员保护）。
 */
@Service
public class RoleService {

    /** 内存数据存储 */
    private final Map<Long, Role> roleMap = new ConcurrentHashMap<>();

    private final AtomicLong idGenerator = new AtomicLong(100);

    /**
     * 新增角色。
     *
     * @requirement(name="角色管理", id="SRS-IMS_F-002")
     *
     * @param role 角色信息
     * @return 创建后的角色
     */
    public Role createRole(Role role) {
        long roleId = idGenerator.incrementAndGet();
        role.setRoleId(roleId);
        role.setIsSuperAdmin(false);
        role.setCreateTime(LocalDateTime.now());
        role.setUpdateTime(LocalDateTime.now());
        if (role.getStatus() == null) {
            role.setStatus(1);
        }
        if (role.getPermissions() == null) {
            role.setPermissions(new ArrayList<>());
        }
        roleMap.put(roleId, role);
        return role;
    }

    /**
     * 编辑角色。
     *
     * @requirement(name="角色管理", id="SRS-IMS_F-002")
     *
     * @param id   角色ID
     * @param role 更新后的角色信息
     * @return 更新后的角色
     */
    public Role updateRole(Long id, Role role) {
        Role existing = roleMap.get(id);
        if (existing == null) {
            throw new IllegalArgumentException("角色不存在，ID: " + id);
        }
        if (role.getRoleName() != null) {
            existing.setRoleName(role.getRoleName());
        }
        if (role.getRoleCode() != null) {
            existing.setRoleCode(role.getRoleCode());
        }
        if (role.getStatus() != null) {
            existing.setStatus(role.getStatus());
        }
        if (role.getPermissions() != null) {
            existing.setPermissions(role.getPermissions());
        }
        existing.setUpdateTime(LocalDateTime.now());
        roleMap.put(id, existing);
        return existing;
    }

    /**
     * 删除角色（超级管理员角色不可删除）。
     *
     * @requirement(name="角色管理", id="SRS-IMS_F-002")
     * 超级管理员角色受保护，不允许删除。
     *
     * @param id 角色ID
     */
    public void deleteRole(Long id) {
        Role existing = roleMap.get(id);
        if (existing == null) {
            throw new IllegalArgumentException("角色不存在，ID: " + id);
        }
        if (Boolean.TRUE.equals(existing.getIsSuperAdmin())) {
            throw new IllegalStateException("超级管理员角色不可删除");
        }
        roleMap.remove(id);
    }

    /**
     * 根据ID查询角色。
     *
     * @requirement(name="角色管理", id="SRS-IMS_F-002")
     *
     * @param id 角色ID
     * @return 角色信息
     */
    public Role getRole(Long id) {
        Role role = roleMap.get(id);
        if (role == null) {
            throw new IllegalArgumentException("角色不存在，ID: " + id);
        }
        return role;
    }

    /**
     * 查询角色列表，支持关键字搜索。
     *
     * @requirement(name="角色管理", id="SRS-IMS_F-002")
     *
     * @param keyword 搜索关键字（可选，匹配角色名称）
     * @return 角色列表
     */
    public List<Role> listRoles(String keyword) {
        List<Role> allRoles = new ArrayList<>(roleMap.values());
        if (keyword != null && !keyword.isBlank()) {
            String kw = keyword.toLowerCase();
            allRoles = allRoles.stream()
                    .filter(r -> r.getRoleName() != null && r.getRoleName().toLowerCase().contains(kw))
                    .collect(Collectors.toList());
        }
        return allRoles;
    }

    /**
     * 分配角色权限（权限树分配，含菜单权限、按钮权限、数据权限）。
     *
     * @requirement(name="角色权限分配", id="SRS-IMS_F-006")
     * @requirement(name="菜单权限管理", id="SRS-IMS_F-007")
     * @requirement(name="按钮权限管理", id="SRS-IMS_F-008")
     * @requirement(name="数据权限分级管控", id="SRS-IMS_F-009")
     *
     * @param roleId      角色ID
     * @param permissions 分配的权限标识列表
     * @return 更新后的角色
     */
    public Role assignPermissions(Long roleId, List<String> permissions) {
        Role existing = roleMap.get(roleId);
        if (existing == null) {
            throw new IllegalArgumentException("角色不存在，ID: " + roleId);
        }
        existing.setPermissions(permissions);
        existing.setUpdateTime(LocalDateTime.now());
        roleMap.put(roleId, existing);
        return existing;
    }

    /**
     * 初始化默认角色数据。
     */
    @PostConstruct
    public void initDefaultRoles() {
        if (roleMap.isEmpty()) {
            List<String> adminPermissions = List.of(
                    "menu:system", "menu:user", "menu:role", "menu:dept",
                    "menu:business", "menu:statistics", "menu:log", "menu:dict",
                    "btn:add", "btn:edit", "btn:delete", "btn:submit",
                    "btn:approve", "btn:reject", "btn:archive", "btn:export",
                    "data:all"
            );
            Role adminRole = new Role(1L, "超级管理员", "ROLE_ADMIN",
                    true, adminPermissions, 1);
            adminRole.setCreateTime(LocalDateTime.now());
            adminRole.setUpdateTime(LocalDateTime.now());
            roleMap.put(1L, adminRole);

            List<String> userPermissions = List.of(
                    "menu:business", "menu:statistics",
                    "btn:add", "btn:edit", "btn:submit",
                    "data:self"
            );
            Role userRole = new Role(2L, "普通用户", "ROLE_USER",
                    false, userPermissions, 1);
            userRole.setCreateTime(LocalDateTime.now());
            userRole.setUpdateTime(LocalDateTime.now());
            roleMap.put(2L, userRole);
        }
    }
}
