package com.example.demo.service;

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

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;

/**
 * 角色管理服务。
 * <p>基于内存数据存储，提供角色的创建、修改、删除、查询及权限分配。</p>
 */
@Service
public class RoleService {

    private final Map<Long, Role> roleStore = new ConcurrentHashMap<>();
    private final AtomicLong idGenerator = new AtomicLong(1);

    /** 角色-权限关联（roleId -> Set<permissionId>） */
    private final Map<Long, Set<Long>> rolePermissionStore = new ConcurrentHashMap<>();

    public RoleService() {
        initMockData();
    }

    private void initMockData() {
        save(new Role(1L, "管理员", "ADMIN", 1, "2024-01-01 00:00:00"));
        save(new Role(2L, "普通用户", "USER", 1, "2024-01-01 00:00:00"));
        save(new Role(3L, "审核员", "AUDITOR", 1, "2024-01-01 00:00:00"));
        rolePermissionStore.put(1L, new HashSet<>(Set.of(1L, 2L, 3L, 4L, 5L)));
        rolePermissionStore.put(2L, new HashSet<>(Set.of(1L, 2L)));
        idGenerator.set(4);
    }

    /**
     * 创建角色。
     *
     * @requirement(name="角色管理", id="SRS-F-01-002")
     * @param role 角色信息
     * @return 已保存的角色
     */
    public Role save(Role role) {
        if (role.getRoleId() == null) {
            role.setRoleId(idGenerator.getAndIncrement());
        }
        if (role.getCreateTime() == null) {
            role.setCreateTime(java.time.LocalDateTime.now().toString().replace("T", " "));
        }
        if (role.getStatus() == null) {
            role.setStatus(1);
        }
        roleStore.put(role.getRoleId(), role);
        return role;
    }

    /**
     * 修改角色信息。
     *
     * @requirement(name="角色管理", id="SRS-F-01-002")
     * @param role 包含更新信息的角色对象
     * @return 更新后的角色，若ID不存在返回 null
     */
    public Role update(Role role) {
        Role existing = roleStore.get(role.getRoleId());
        if (existing == null) {
            return null;
        }
        if (role.getRoleName() != null) existing.setRoleName(role.getRoleName());
        if (role.getRoleCode() != null) existing.setRoleCode(role.getRoleCode());
        if (role.getStatus() != null) existing.setStatus(role.getStatus());
        return existing;
    }

    /**
     * 删除角色。
     *
     * @requirement(name="角色管理", id="SRS-F-01-002")
     * @param roleId 角色ID
     * @return 是否删除成功
     */
    public boolean deleteById(Long roleId) {
        rolePermissionStore.remove(roleId);
        return roleStore.remove(roleId) != null;
    }

    /**
     * 查询角色列表。
     *
     * @requirement(name="角色管理", id="SRS-F-01-002")
     * @param roleName 角色名称（可选，模糊匹配）
     * @return 角色列表
     */
    public List<Role> list(String roleName) {
        return roleStore.values().stream()
                .filter(r -> roleName == null || r.getRoleName().contains(roleName))
                .collect(Collectors.toList());
    }

    /**
     * 根据ID查询角色。
     *
     * @param roleId 角色ID
     * @return 角色对象
     */
    public Role findById(Long roleId) {
        return roleStore.get(roleId);
    }

    /**
     * 为角色分配权限。
     *
     * @requirement(name="角色管理", id="SRS-F-01-002")
     * @param roleId        角色ID
     * @param permissionIds 权限ID集合
     * @return 是否分配成功（角色不存在返回 false）
     */
    public boolean assignPermissions(Long roleId, Set<Long> permissionIds) {
        if (!roleStore.containsKey(roleId)) {
            return false;
        }
        rolePermissionStore.put(roleId, new HashSet<>(permissionIds));
        return true;
    }

    /**
     * 获取角色的权限ID集合。
     *
     * @param roleId 角色ID
     * @return 权限ID集合
     */
    public Set<Long> getPermissionIds(Long roleId) {
        return rolePermissionStore.getOrDefault(roleId, Collections.emptySet());
    }

    /**
     * 获取所有角色。
     *
     * @return 所有角色列表
     */
    public List<Role> findAll() {
        return new ArrayList<>(roleStore.values());
    }
}
