package com.aigeo.company.controller;

import com.aigeo.company.entity.User;
import com.aigeo.company.service.UserService;
import com.aigeo.common.result.Result;
import com.aigeo.common.result.ResultCode;
import com.aigeo.common.exception.BusinessException;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 用户管理控制器
 * 
 * @author AIGEO Team
 * @since 1.0.0
 */
@Tag(name = "用户管理", description = "用户信息管理接口，支持用户的创建、查询、更新和删除操作")
@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
@Slf4j
public class UserController {
    
    private final UserService userService;

    @Operation(
        summary = "分页查询用户列表", 
        description = "支持按用户名、邮箱、角色等条件分页查询用户列表，默认按创建时间倒序排列"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "400", description = "请求参数错误"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/list")
    public Result<Page<User>> listUsers(
        @Parameter(description = "页码，从0开始", example = "0") 
        @RequestParam(defaultValue = "0") int page,
        
        @Parameter(description = "页大小，默认10条", example = "10") 
        @RequestParam(defaultValue = "10") int size,
        
        @Parameter(description = "公司ID（可选）") 
        @RequestParam(required = false) Integer companyId,
        
        @Parameter(description = "用户名（模糊查询）") 
        @RequestParam(required = false) String username,
        
        @Parameter(description = "邮箱（模糊查询）") 
        @RequestParam(required = false) String email,
        
        @Parameter(description = "用户角色（ADMIN/USER/EDITOR）") 
        @RequestParam(required = false) String role,
        
        @Parameter(description = "用户状态（true为活跃，false为禁用）") 
        @RequestParam(required = false) Boolean isActive
    ) {
        try {
            Pageable pageable = PageRequest.of(page, size, Sort.by(Sort.Direction.DESC, "createdAt"));
            Page<User> users = userService.searchUsers(companyId, username, email, role, isActive, pageable);
            return Result.success("查询成功", users);
        } catch (Exception e) {
            log.error("分页查询用户列表失败", e);
            return Result.error("查询失败");
        }
    }

    @Operation(
        summary = "获取所有用户（简化版）", 
        description = "获取所有用户的基本信息，用于下拉选择等场景"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping
    public Result<List<User>> getAllUsers() {
        try {
            List<User> users = userService.getAllUsers();
            return Result.success("查询成功", users);
        } catch (Exception e) {
            log.error("获取所有用户失败", e);
            return Result.error("查询失败");
        }
    }
    
    @Operation(
        summary = "根据ID查询用户详情", 
        description = "通过用户ID获取用户的详细信息"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "404", description = "用户不存在"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/{id}")
    public Result<User> getUserById(
        @Parameter(description = "用户ID", required = true, example = "1") 
        @PathVariable @NotNull Integer id
    ) {
        try {
            User user = userService.getUserById(id);
            return Result.success("查询成功", user);
        } catch (BusinessException e) {
            log.warn("根据ID查询用户失败, id: {}, error: {}", id, e.getMessage());
            return Result.error(ResultCode.getByCode(e.getResultCode()));


        } catch (Exception e) {
            log.error("根据ID查询用户详情失败, id: {}", id, e);
            return Result.error("查询失败");
        }
    }

    @Operation(
        summary = "根据公司ID查询用户列表", 
        description = "获取指定公司下的所有用户"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "404", description = "公司不存在"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/company/{companyId}")
    public Result<List<User>> getUsersByCompanyId(
        @Parameter(description = "公司ID", required = true, example = "1") 
        @PathVariable @NotNull Integer companyId
    ) {
        try {
            List<User> users = userService.getUsersByCompanyId(companyId);
            return Result.success("查询成功", users);
        } catch (Exception e) {
            log.error("根据公司ID查询用户列表失败, companyId: {}", companyId, e);
            return Result.error("查询失败");
        }
    }

    @Operation(
        summary = "根据用户名查询用户", 
        description = "通过用户名获取用户信息，用于登录验证等场景"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "404", description = "用户不存在"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/username/{username}")
    public Result<User> getUserByUsername(
        @Parameter(description = "用户名", required = true, example = "admin") 
        @PathVariable @NotNull String username
    ) {
        try {
            User user = userService.getUserByUsername(username);
            return Result.success("查询成功", user);
        } catch (BusinessException e) {
            log.warn("根据用户名查询用户失败, username: {}, error: {}", username, e.getMessage());
            return Result.error(ResultCode.getByCode(e.getResultCode()));

        } catch (Exception e) {
            log.error("根据用户名查询用户失败, username: {}", username, e);
            return Result.error("查询失败");
        }
    }

    @Operation(
        summary = "根据邮箱查询用户", 
        description = "通过邮箱获取用户信息，用于找回密码等场景"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "404", description = "用户不存在"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/email/{email}")
    public Result<User> getUserByEmail(
        @Parameter(description = "用户邮箱", required = true, example = "admin@aigeo.com") 
        @PathVariable @NotNull String email
    ) {
        try {
            User user = userService.getUserByEmail(email);
            return Result.success("查询成功", user);
        } catch (BusinessException e) {
            log.warn("根据邮箱查询用户失败, email: {}, error: {}", email, e.getMessage());
            return Result.error(ResultCode.getByCode(e.getResultCode()));

        } catch (Exception e) {
            log.error("根据邮箱查询用户失败, email: {}", email, e);
            return Result.error("查询失败");
        }
    }

    @Operation(
        summary = "查询活跃用户列表", 
        description = "获取所有状态为活跃的用户列表"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "查询成功"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/active")
    public Result<List<User>> getActiveUsers(
        @Parameter(description = "公司ID（可选）") 
        @RequestParam(required = false) Integer companyId
    ) {
        try {
            List<User> users = userService.getActiveUsers(companyId);
            return Result.success("查询成功", users);
        } catch (Exception e) {
            log.error("查询活跃用户列表失败", e);
            return Result.error("查询失败");
        }
    }
    
    @Operation(
        summary = "创建新用户", 
        description = "创建一个新的用户记录，包含基本信息和权限配置"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "创建成功"),
        @ApiResponse(responseCode = "400", description = "请求参数错误"),
        @ApiResponse(responseCode = "409", description = "用户名或邮箱已存在"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @PostMapping
    public Result<User> createUser(
        @Parameter(description = "用户信息", required = true) 
        @Valid @RequestBody User user
    ) {
        try {
            // 检查用户名是否已存在
            if (userService.existsByUsername(user.getUsername())) {
                return Result.error(ResultCode.USERNAME_EXISTS);
            }
            
            // 检查邮箱是否已存在
            if (userService.existsByEmail(user.getEmail())) {
                return Result.error(ResultCode.EMAIL_EXISTS);
            }
            
            User savedUser = userService.saveUser(user);
            log.info("成功创建用户: {}", savedUser.getUsername());
            return Result.success("创建成功", savedUser);
        } catch (Exception e) {
            log.error("创建用户失败", e);
            return Result.error("创建失败");
        }
    }
    
    @Operation(
        summary = "更新用户信息", 
        description = "根据ID更新用户的详细信息"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "更新成功"),
        @ApiResponse(responseCode = "400", description = "请求参数错误"),
        @ApiResponse(responseCode = "404", description = "用户不存在"),
        @ApiResponse(responseCode = "409", description = "用户名或邮箱冲突"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @PutMapping("/{id}")
    public Result<User> updateUser(
        @Parameter(description = "用户ID", required = true, example = "1") 
        @PathVariable @NotNull Integer id,
        
        @Parameter(description = "更新的用户信息", required = true) 
        @Valid @RequestBody User userDetails
    ) {
        try {
            User existingUser = userService.getUserById(id);
            
            // 检查用户名冲突（排除当前用户）
            if (!existingUser.getUsername().equals(userDetails.getUsername()) 
                && userService.existsByUsername(userDetails.getUsername())) {
                return Result.error(ResultCode.USERNAME_EXISTS);
            }
            
            // 检查邮箱冲突（排除当前用户）
            if (!existingUser.getEmail().equals(userDetails.getEmail()) 
                && userService.existsByEmail(userDetails.getEmail())) {
                return Result.error(ResultCode.EMAIL_EXISTS);
            }
            
            // 更新字段
            existingUser.setUsername(userDetails.getUsername());
            existingUser.setEmail(userDetails.getEmail());
            existingUser.setFullName(userDetails.getFullName());
            existingUser.setRole(userDetails.getRole());
            existingUser.setIsActive(userDetails.getIsActive());
            
            User savedUser = userService.saveUser(existingUser);
            log.info("成功更新用户: {}", savedUser.getUsername());
            return Result.success("更新成功", savedUser);
        } catch (Exception e) {
            log.error("更新用户失败, id: {}", id, e);
            return Result.error("更新失败");
        }
    }

    @Operation(
        summary = "批量更新用户状态", 
        description = "批量更新多个用户的激活状态"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "更新成功"),
        @ApiResponse(responseCode = "400", description = "请求参数错误"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @PutMapping("/batch-status")
    public Result<String> batchUpdateStatus(
        @Parameter(description = "用户ID列表", required = true) 
        @RequestParam @NotNull List<Integer> ids,
        
        @Parameter(description = "新状态（true为激活，false为禁用）", required = true) 
        @RequestParam @NotNull Boolean isActive
    ) {
        try {
            int updatedCount = userService.batchUpdateStatus(ids, isActive);
            log.info("批量更新用户状态成功，更新数量: {}", updatedCount);
            return Result.success(String.format("成功更新 %d 个用户状态", updatedCount));
        } catch (Exception e) {
            log.error("批量更新用户状态失败", e);
            return Result.error("批量更新失败");
        }
    }

    @Operation(
        summary = "重置用户密码", 
        description = "管理员重置用户密码，生成临时密码"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "重置成功"),
        @ApiResponse(responseCode = "404", description = "用户不存在"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @PostMapping("/{id}/reset-password")
    public Result<String> resetPassword(
        @Parameter(description = "用户ID", required = true, example = "1") 
        @PathVariable @NotNull Integer id
    ) {
        try {
            if (!userService.existsById(id)) {
                return Result.error(ResultCode.USER_NOT_FOUND);
            }
            
            String tempPassword = userService.resetPassword(id);
            log.info("成功重置用户密码, id: {}", id);
            return Result.success("密码重置成功，临时密码已生成", tempPassword);
        } catch (Exception e) {
            log.error("重置用户密码失败, id: {}", id, e);
            return Result.error("密码重置失败");
        }
    }
    
    @Operation(
        summary = "删除用户", 
        description = "根据ID删除用户记录（软删除）"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "删除成功"),
        @ApiResponse(responseCode = "404", description = "用户不存在"),
        @ApiResponse(responseCode = "409", description = "用户有关联数据，无法删除"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @DeleteMapping("/{id}")
    public Result<String> deleteUser(
        @Parameter(description = "用户ID", required = true, example = "1") 
        @PathVariable @NotNull Integer id
    ) {
        try {
            if (!userService.existsById(id)) {
                return Result.error(ResultCode.USER_NOT_FOUND);
            }
            
            // 检查是否有关联数据
            if (userService.hasAssociatedData(id)) {
                return Result.error(ResultCode.CONFLICT, "用户有关联数据，无法删除");
            }
            
            userService.deleteUser(id);
            log.info("成功删除用户, id: {}", id);
            return Result.success("删除成功");
        } catch (Exception e) {
            log.error("删除用户失败, id: {}", id, e);
            return Result.error("删除失败");
        }
    }

    @Operation(
        summary = "搜索用户", 
        description = "根据关键词搜索用户名、邮箱或全名"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "搜索成功"),
        @ApiResponse(responseCode = "400", description = "请求参数错误"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/search")
    public Result<List<User>> searchUsers(
        @Parameter(description = "搜索关键词", required = true, example = "admin") 
        @RequestParam @NotNull String keyword,
        
        @Parameter(description = "公司ID（可选）") 
        @RequestParam(required = false) Integer companyId,
        
        @Parameter(description = "最大返回数量", example = "20") 
        @RequestParam(defaultValue = "20") int limit
    ) {
        try {
            List<User> users = userService.searchByKeyword(keyword, companyId, limit);
            return Result.success("搜索成功", users);
        } catch (Exception e) {
            log.error("搜索用户失败, keyword: {}", keyword, e);
            return Result.error("搜索失败");
        }
    }

    @Operation(
        summary = "统计用户数据", 
        description = "获取用户相关的统计信息"
    )
    @ApiResponses(value = {
        @ApiResponse(responseCode = "200", description = "统计成功"),
        @ApiResponse(responseCode = "500", description = "服务器内部错误")
    })
    @GetMapping("/statistics")
    public Result<UserStatistics> getUserStatistics(
        @Parameter(description = "公司ID（可选）") 
        @RequestParam(required = false) Integer companyId
    ) {
        try {
            UserStatistics statistics = userService.getUserStatistics(companyId);
            return Result.success("统计成功", statistics);
        } catch (Exception e) {
            log.error("获取用户统计信息失败", e);
            return Result.error("统计失败");
        }
    }

    /**
     * 用户统计信息DTO
     */
    public static class UserStatistics {
        private long totalUsers;
        private long activeUsers;
        private long inactiveUsers;
        private long adminUsers;
        private long regularUsers;
        
        // constructors, getters and setters
        public UserStatistics(long totalUsers, long activeUsers, long inactiveUsers, 
                            long adminUsers, long regularUsers) {
            this.totalUsers = totalUsers;
            this.activeUsers = activeUsers;
            this.inactiveUsers = inactiveUsers;
            this.adminUsers = adminUsers;
            this.regularUsers = regularUsers;
        }
        
        // getters and setters
        public long getTotalUsers() { return totalUsers; }
        public void setTotalUsers(long totalUsers) { this.totalUsers = totalUsers; }
        
        public long getActiveUsers() { return activeUsers; }
        public void setActiveUsers(long activeUsers) { this.activeUsers = activeUsers; }
        
        public long getInactiveUsers() { return inactiveUsers; }
        public void setInactiveUsers(long inactiveUsers) { this.inactiveUsers = inactiveUsers; }
        
        public long getAdminUsers() { return adminUsers; }
        public void setAdminUsers(long adminUsers) { this.adminUsers = adminUsers; }
        
        public long getRegularUsers() { return regularUsers; }
        public void setRegularUsers(long regularUsers) { this.regularUsers = regularUsers; }
    }
}