package com.example.ldap.controller;

import com.example.ldap.dto.ApiResponse;
import com.example.ldap.entity.User;
import com.example.ldap.service.UserService;
import jakarta.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;


import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/users")
@CrossOrigin(origins = "*")
public class UserController {

    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    /**
     * 获取所有用户
     */
    @GetMapping
    public ResponseEntity<ApiResponse<List<User>>> getAllUsers() {
        logger.info("API: 获取所有用户");
        List<User> users = userService.getAllUsers();
        return ResponseEntity.ok(ApiResponse.success("获取用户列表成功", users));
    }

    /**
     * 根据用户名获取用户
     */
    @GetMapping("/{username}")
    public ResponseEntity<ApiResponse<User>> getUserByUsername(@PathVariable String username) {
        logger.info("API: 获取用户 {}", username);
        User user = userService.findByUsername(username);
        if (user == null) {
            return ResponseEntity.ok(ApiResponse.error("用户不存在"));
        }
        return ResponseEntity.ok(ApiResponse.success("获取用户成功", user));
    }

    /**
     * 创建新用户
     */
    @PostMapping
    public ResponseEntity<ApiResponse<User>> createUser(@Valid @RequestBody User user) {
        logger.info("API: 创建用户 {}", user.getUsername());
        User createdUser = userService.createUser(user);
        return ResponseEntity.ok(ApiResponse.success("用户创建成功", createdUser));
    }

    /**
     * 更新用户信息
     */
    @PutMapping("/{username}")
    public ResponseEntity<ApiResponse<User>> updateUser(
            @PathVariable String username,
            @RequestBody User user) {
        logger.info("API: 更新用户 {}", username);
        User updatedUser = userService.updateUser(username, user);
        return ResponseEntity.ok(ApiResponse.success("用户更新成功", updatedUser));
    }

    /**
     * 更新用户密码
     */
    @PutMapping("/{username}/password")
    public ResponseEntity<ApiResponse<String>> updatePassword(
            @PathVariable String username,
            @RequestBody Map<String, String> passwordData) {
        logger.info("API: 更新用户密码 {}", username);
        String newPassword = passwordData.get("newPassword");
        if (newPassword == null || newPassword.trim().isEmpty()) {
            return ResponseEntity.badRequest()
                    .body(ApiResponse.error("新密码不能为空"));
        }
        
        userService.updatePassword(username, newPassword);
        return ResponseEntity.ok(ApiResponse.success("密码更新成功"));
    }

    /**
     * 删除用户
     */
    @DeleteMapping("/{username}")
    public ResponseEntity<ApiResponse<String>> deleteUser(@PathVariable String username) {
        logger.info("API: 删除用户 {}", username);
        userService.deleteUser(username);
        return ResponseEntity.ok(ApiResponse.success("用户删除成功"));
    }

    /**
     * 搜索用户
     */
    @GetMapping("/search")
    public ResponseEntity<ApiResponse<List<User>>> searchUsers(
            @RequestParam(required = false) String keyword) {
        logger.info("API: 搜索用户 {}", keyword);
        List<User> users = userService.searchUsers(keyword);
        return ResponseEntity.ok(ApiResponse.success("搜索完成", users));
    }

    /**
     * 验证用户密码
     */
    @PostMapping("/{username}/validate")
    public ResponseEntity<ApiResponse<Boolean>> validatePassword(
            @PathVariable String username,
            @RequestBody Map<String, String> passwordData) {
        logger.info("API: 验证用户密码 {}", username);
        String password = passwordData.get("password");
        if (password == null) {
            return ResponseEntity.badRequest()
                    .body(ApiResponse.error("密码不能为空"));
        }
        
        boolean isValid = userService.validatePassword(username, password);
        return ResponseEntity.ok(ApiResponse.success("验证完成", isValid));
    }

    /**
     * 批量创建用户
     */
    @PostMapping("/batch")
    public ResponseEntity<ApiResponse<List<User>>> createUsers(@Valid @RequestBody List<User> users) {
        logger.info("API: 批量创建用户，数量: {}", users.size());
        
        List<User> createdUsers = users.stream()
                .map(userService::createUser)
                .toList();
        
        return ResponseEntity.ok(ApiResponse.success("批量创建用户成功", createdUsers));
    }

    /**
     * 获取用户统计信息
     */
    @GetMapping("/statistics")
    public ResponseEntity<ApiResponse<Map<String, Object>>> getUserStatistics() {
        logger.info("API: 获取用户统计信息");
        
        List<User> allUsers = userService.getAllUsers();
        Map<String, Object> stats = Map.of(
                "totalUsers", allUsers.size(),
                "usersWithEmail", allUsers.stream()
                        .mapToLong(u -> u.getEmail() != null && !u.getEmail().isEmpty() ? 1 : 0)
                        .sum(),
                "usersWithPhone", allUsers.stream()
                        .mapToLong(u -> u.getPhoneNumber() != null && !u.getPhoneNumber().isEmpty() ? 1 : 0)
                        .sum()
        );
        
        return ResponseEntity.ok(ApiResponse.success("获取统计信息成功", stats));
    }
}