package com.example.demo.service;

import com.example.demo.model.User;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
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 UserService {

    private final PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

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

    private final AtomicLong idGenerator = new AtomicLong(1000);

    /**
     * 新增用户。
     *
     * @requirement(name="用户管理", id="SRS-IMS_F-001")
     * 创建用户时使用 BCrypt 对密码进行加密存储。
     *
     * @param user 用户信息（密码明文传入，内部加密存储）
     * @return 创建后的用户
     */
    public User createUser(User user) {
        long userId = idGenerator.incrementAndGet();
        user.setUserId(userId);
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        user.setCreateTime(LocalDateTime.now());
        user.setUpdateTime(LocalDateTime.now());
        if (user.getStatus() == null) {
            user.setStatus(1);
        }
        userMap.put(userId, user);
        return user;
    }

    /**
     * 编辑用户。
     *
     * @requirement(name="用户管理", id="SRS-IMS_F-001")
     * 更新用户信息，若密码变更则重新加密。
     *
     * @param id   用户ID
     * @param user 更新后的用户信息
     * @return 更新后的用户
     */
    public User updateUser(Long id, User user) {
        User existing = userMap.get(id);
        if (existing == null) {
            throw new IllegalArgumentException("用户不存在，ID: " + id);
        }
        if (user.getUsername() != null) {
            existing.setUsername(user.getUsername());
        }
        if (user.getRealName() != null) {
            existing.setRealName(user.getRealName());
        }
        if (user.getPassword() != null && !user.getPassword().isBlank()) {
            existing.setPassword(passwordEncoder.encode(user.getPassword()));
        }
        if (user.getDeptId() != null) {
            existing.setDeptId(user.getDeptId());
        }
        if (user.getRoleId() != null) {
            existing.setRoleId(user.getRoleId());
        }
        if (user.getPhone() != null) {
            existing.setPhone(user.getPhone());
        }
        if (user.getStatus() != null) {
            existing.setStatus(user.getStatus());
        }
        existing.setUpdateTime(LocalDateTime.now());
        userMap.put(id, existing);
        return existing;
    }

    /**
     * 删除用户。
     *
     * @requirement(name="用户管理", id="SRS-IMS_F-001")
     *
     * @param id 用户ID
     */
    public void deleteUser(Long id) {
        if (!userMap.containsKey(id)) {
            throw new IllegalArgumentException("用户不存在，ID: " + id);
        }
        userMap.remove(id);
    }

    /**
     * 根据ID查询用户。
     *
     * @requirement(name="用户管理", id="SRS-IMS_F-001")
     *
     * @param id 用户ID
     * @return 用户信息
     */
    public User getUser(Long id) {
        User user = userMap.get(id);
        if (user == null) {
            throw new IllegalArgumentException("用户不存在，ID: " + id);
        }
        return user;
    }

    /**
     * 查询用户列表，支持关键字模糊查询和分页。
     *
     * @requirement(name="用户管理", id="SRS-IMS_F-001")
     * 支持按用户名、姓名模糊搜索。
     *
     * @param keyword 搜索关键字（可选，匹配用户名或姓名）
     * @param page    页码（从0开始）
     * @param size    每页条数
     * @return 用户列表
     */
    public List<User> listUsers(String keyword, int page, int size) {
        List<User> allUsers = new ArrayList<>(userMap.values());
        if (keyword != null && !keyword.isBlank()) {
            String kw = keyword.toLowerCase();
            allUsers = allUsers.stream()
                    .filter(u -> (u.getUsername() != null && u.getUsername().toLowerCase().contains(kw))
                            || (u.getRealName() != null && u.getRealName().toLowerCase().contains(kw)))
                    .collect(Collectors.toList());
        }
        int start = page * size;
        if (start >= allUsers.size()) {
            return List.of();
        }
        int end = Math.min(start + size, allUsers.size());
        return allUsers.subList(start, end);
    }

    /**
     * 初始化默认用户数据。
     */
    public void initDefaultUsers() {
        if (userMap.isEmpty()) {
            User admin = new User(1L, "admin", passwordEncoder.encode("admin123"),
                    "管理员", 1L, 1L, "13800000000", 1);
            admin.setCreateTime(LocalDateTime.now());
            admin.setUpdateTime(LocalDateTime.now());
            userMap.put(1L, admin);

            User user = new User(2L, "zhangsan", passwordEncoder.encode("123456"),
                    "张三", 2L, 2L, "13900000001", 1);
            user.setCreateTime(LocalDateTime.now());
            user.setUpdateTime(LocalDateTime.now());
            userMap.put(2L, user);
        }
    }
}
