/**
 * 用户模型 - 纯业务对象，不包含任何Web层依赖
 */
public class User {
    private Long id;
    private String username;
    private String email;
    private LocalDateTime createTime;
    
    // 业务逻辑方法
    public boolean isActive() {
        return createTime != null && createTime.isAfter(LocalDateTime.now().minusMonths(1));
    }
    
    // 数据验证方法
    public boolean isValidEmail() {
        return email != null && email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }
    
    // getters and setters...
}

@RestController
@RequestMapping("/api/v1/products")
public class ProductController {
    
    /**
     * 基础的CRUD映射
     */
    @GetMapping                    // GET /api/v1/products
    public List<Product> getAllProducts() { ... }
    
    @GetMapping("/{id}")          // GET /api/v1/products/123
    public Product getProduct(@PathVariable Long id) { ... }
    
    @PostMapping                   // POST /api/v1/products
    public Product createProduct(@RequestBody Product product) { ... }
    
    @PutMapping("/{id}")          // PUT /api/v1/products/123
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) { ... }
    
    @DeleteMapping("/{id}")       // DELETE /api/v1/products/123
    public void deleteProduct(@PathVariable Long id) { ... }
    
    /**
     * 复杂的路径变量映射
     */
    @GetMapping("/category/{category}/price/{min}-{max}")
    public List<Product> findByPriceRange(@PathVariable String category,
                                         @PathVariable BigDecimal min,
                                         @PathVariable BigDecimal max) { ... }
    
    /**
     * 多参数映射与默认值
     */
    @GetMapping("/search")
    public List<Product> searchProducts(
            @RequestParam(required = false) String keyword,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(defaultValue = "name") String sortBy) { ... }
    
    /**
     * 正则表达式路径变量
     */
    @GetMapping("/batch/{ids:[\\d,]+}")
    public List<Product> getBatchProducts(@PathVariable String ids) { ... }
    
    /**
     * 通配符映射
     */
    @GetMapping("/files/**")
    public Resource getFile(@PathVariable String path) { ... }
}

/**
 * 用户控制器 - 遵循单一职责和依赖注入原则
 */
@Controller
@RequestMapping("/users")
public class UserController {
    
    private final UserService userService;
    private final UserValidator userValidator;
    
    // 构造函数注入，推荐方式
    public UserController(UserService userService, UserValidator userValidator) {
        this.userService = userService;
        this.userValidator = userValidator;
    }
    
    /**
     * 显示用户列表页面
     */
    @GetMapping
    public String listUsers(Model model, 
                           @RequestParam(defaultValue = "0") int page,
                           @RequestParam(defaultValue = "10") int size) {
        Page<User> userPage = userService.findUsers(page, size);
        model.addAttribute("userPage", userPage);
        return "users/list"; // 返回视图名称
    }
    
    /**
     * 显示用户详情页面
     */
    @GetMapping("/{id}")
    public String showUser(@PathVariable Long id, Model model) {
        User user = userService.findById(id)
            .orElseThrow(() -> new UserNotFoundException("用户不存在: " + id));
        model.addAttribute("user", user);
        return "users/detail";
    }
    
    /**
     * 处理用户创建表单提交
     */
    @PostMapping
    public String createUser(@Valid @ModelAttribute UserCreateForm form, 
                           BindingResult result,
                           RedirectAttributes redirectAttributes) {
        
        // 自定义验证
        userValidator.validate(form, result);
        if (result.hasErrors()) {
            return "users/create-form"; // 验证失败，返回表单页面
        }
        
        User user = userService.createUser(form.toUser());
        redirectAttributes.addFlashAttribute("message", "用户创建成功");
        return "redirect:/users/" + user.getId(); // 重定向到详情页
    }
}

// DTO 分组校验
public class UserCreateReq {
  @NotBlank(groups = Create.class)
  @Size(max = 32, groups = {Create.class, Update.class})
  private String nickname;

  @Email(groups = {Create.class, Update.class})
  private String email;

  public interface Create {}
  public interface Update {}
}

@RestController
@Validated
public class UserController {
  @PostMapping("/users")
  public ResponseEntity<?> create(@Validated(UserCreateReq.Create.class) @RequestBody UserCreateReq req) {
    // 业务处理
    return ResponseEntity.ok().build();
  }

  @InitBinder
  public void init(WebDataBinder binder){
    binder.initDirectFieldAccess();
  }
}

/**
 * 自定义密码强度验证注解
 */
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PasswordStrengthValidator.class)
public @interface PasswordStrength {
    String message() default "密码必须包含大小写字母、数字和特殊字符，长度8-20位";
    
    Class<?>[] groups() default {};
    
    Class<? extends Payload>[] payload() default {};
    
    // 可配置的最小长度
    int minLength() default 8;
    
    // 是否需要特殊字符
    boolean requireSpecialChar() default true;
}

/**
 * 密码强度验证器实现
 */
public class PasswordStrengthValidator implements ConstraintValidator<PasswordStrength, String> {
    
    private int minLength;
    private boolean requireSpecialChar;
    
    @Override
    public void initialize(PasswordStrength constraintAnnotation) {
        this.minLength = constraintAnnotation.minLength();
        this.requireSpecialChar = constraintAnnotation.requireSpecialChar();
    }
    
    @Override
    public boolean isValid(String password, ConstraintValidatorContext context) {
        if (password == null) return false;
        
        // 长度检查
        if (password.length() < minLength) return false;
        
        // 包含大写字母
        if (!password.matches(".*[A-Z].*")) return false;
        
        // 包含小写字母
        if (!password.matches(".*[a-z].*")) return false;
        
        // 包含数字
        if (!password.matches(".*\\d.*")) return false;
        
        // 包含特殊字符
        if (requireSpecialChar && !password.matches(".*[!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?].*")) {
            return false;
        }
        
        return true;
    }
}

/**
 * 在DTO中使用自定义验证
 */
public class UserRegistrationDto {
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 20, message = "用户名长度必须在3-20位之间")
    private String username;
    
    @NotBlank(message = "密码不能为空")
    @PasswordStrength(minLength = 10, requireSpecialChar = true)
    private String password;
    
    @Email(message = "邮箱格式不正确")
    @NotBlank(message = "邮箱不能为空")
    private String email;
    
    // 自定义验证：确认密码
    @AssertTrue(message = "两次输入的密码不一致")
    public boolean isPasswordMatching() {
        return password != null && password.equals(confirmPassword);
    }
    
    private String confirmPassword;
    
    // getters and setters...
}

@ControllerAdvice
public class GlobalExceptionHandler {
  @ExceptionHandler(MethodArgumentNotValidException.class)
  public ResponseEntity<Map<String, Object>> handleValid(MethodArgumentNotValidException e){
    Map<String,Object> body = new HashMap<>();
    body.put("code", "VALIDATION_ERROR");
    body.put("message", e.getBindingResult().getFieldError().getDefaultMessage());
    return ResponseEntity.badRequest().body(body);
  }

  @ExceptionHandler(NoHandlerFoundException.class)
  public ResponseEntity<Map<String, Object>> handle404(NoHandlerFoundException e){
    Map<String,Object> body = new HashMap<>();
    body.put("code", "NOT_FOUND");
    body.put("path", e.getRequestURL());
    return ResponseEntity.status(HttpStatus.NOT_FOUND).body(body);
  }
}

record ApiResp<T>(int code, String msg, T data) {}

@GetMapping(value = "/api/users", produces = "application/vnd.api.v1+json")
public ResponseEntity<ApiResp<List<User>>> listV1(){
  return ResponseEntity.ok(new ApiResp<>(0, "ok", List.of()));
}

@GetMapping(value = "/api/users", produces = "application/vnd.api.v2+json")
public ResponseEntity<ApiResp<Map<String,Object>>> listV2(){
  Map<String,Object> page = Map.of("items", List.of(), "total", 0);
  return ResponseEntity.ok(new ApiResp<>(0, "ok", page));
}

/**
 * 订单管理API控制器
 * 展示RESTful API设计的完整实现
 */
@RestController
@RequestMapping("/api/v1/orders")
@Validated
@Slf4j
public class OrderApiController {

    private final OrderService orderService;
    private final OrderMapper orderMapper;

    public OrderApiController(OrderService orderService, OrderMapper orderMapper) {
        this.orderService = orderService;
        this.orderMapper = orderMapper;
    }

    /**
     * 创建订单 - POST /api/v1/orders
     */
    @PostMapping
    public ResponseEntity<ApiResponse<OrderDto>> createOrder(
            @Valid @RequestBody CreateOrderRequest request,
            Authentication authentication) {
        
        log.info("用户 {} 创建订单: {}", authentication.getName(), request);
        
        Order order = orderService.createOrder(authentication.getName(), request);
        OrderDto orderDto = orderMapper.toDto(order);
        
        return ResponseEntity
                .status(HttpStatus.CREATED)
                .body(ApiResponse.success(orderDto, "订单创建成功"));
    }

    /**
     * 分页查询订单 - GET /api/v1/orders
     */
    @GetMapping
    public ResponseEntity<ApiResponse<PageResult<OrderDto>>> getOrders(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size,
            @RequestParam(required = false) OrderStatus status,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate,
            Authentication authentication) {
        
        OrderQuery query = OrderQuery.builder()
                .userId(authentication.getName())
                .status(status)
                .startDate(startDate)
                .endDate(endDate)
                .page(page)
                .size(size)
                .build();
        
        PageResult<Order> orders = orderService.getOrders(query);
        PageResult<OrderDto> result = orderMapper.toPageDto(orders);
        
        return ResponseEntity.ok(ApiResponse.success(result));
    }

    /**
     * 获取订单详情 - GET /api/v1/orders/{id}
     */
    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<OrderDetailDto>> getOrder(
            @PathVariable Long id,
            Authentication authentication) {
        
        Order order = orderService.getOrder(id, authentication.getName());
        OrderDetailDto orderDetail = orderMapper.toDetailDto(order);
        
        return ResponseEntity.ok(ApiResponse.success(orderDetail));
    }

    /**
     * 更新订单状态 - PATCH /api/v1/orders/{id}/status
     */
    @PatchMapping("/{id}/status")
    public ResponseEntity<ApiResponse<Void>> updateOrderStatus(
            @PathVariable Long id,
            @Valid @RequestBody UpdateStatusRequest request,
            Authentication authentication) {
        
        orderService.updateOrderStatus(id, request.getStatus(), 
                request.getReason(), authentication.getName());
        
        return ResponseEntity.ok(ApiResponse.success(null, "订单状态更新成功"));
    }

    /**
     * 取消订单 - DELETE /api/v1/orders/{id}
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> cancelOrder(
            @PathVariable Long id,
            @RequestParam(required = false) String reason,
            Authentication authentication) {
        
        orderService.cancelOrder(id, reason, authentication.getName());
        
        return ResponseEntity.ok(ApiResponse.success(null, "订单取消成功"));
    }

    /**
     * 导出订单 - GET /api/v1/orders/export
     */
    @GetMapping("/export")
    public ResponseEntity<Resource> exportOrders(
            @RequestParam(required = false) OrderStatus status,
            @RequestParam(defaultValue = "EXCEL") ExportFormat format,
            Authentication authentication) {
        
        OrderQuery query = OrderQuery.builder()
                .userId(authentication.getName())
                .status(status)
                .build();
        
        String filename = "orders_" + System.currentTimeMillis() + "." + format.name().toLowerCase();
        Resource resource = orderService.exportOrders(query, format);
        
        return ResponseEntity.ok()
                .contentType(MediaType.APPLICATION_OCTET_STREAM)
                .header(HttpHeaders.CONTENT_DISPOSITION, 
                        "attachment; filename=\"" + filename + "\"")
                .body(resource);
    }

    /**
     * 订单统计 - GET /api/v1/orders/statistics
     */
    @GetMapping("/statistics")
    public ResponseEntity<ApiResponse<OrderStatisticsDto>> getOrderStatistics(
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate,
            Authentication authentication) {
        
        OrderStatistics statistics = orderService.getOrderStatistics(
                authentication.getName(), startDate, endDate);
        OrderStatisticsDto statisticsDto = orderMapper.toStatisticsDto(statistics);
        
        return ResponseEntity.ok(ApiResponse.success(statisticsDto));
    }

    // 异常处理
    @ExceptionHandler(OrderNotFoundException.class)
    public ResponseEntity<ApiResponse<Void>> handleOrderNotFound(OrderNotFoundException e) {
        return ResponseEntity
                .status(HttpStatus.NOT_FOUND)
                .body(ApiResponse.error(e.getMessage()));
    }

    @ExceptionHandler(OrderStatusException.class)
    public ResponseEntity<ApiResponse<Void>> handleOrderStatus(OrderStatusException e) {
        return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(ApiResponse.error(e.getMessage()));
    }
}

/**
 * API请求DTO
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CreateOrderRequest {
    
    @NotNull(message = "收货地址不能为空")
    private Long addressId;
    
    @NotEmpty(message = "订单项不能为空")
    @Size(min = 1, message = "至少需要一个订单项")
    private List<OrderItemRequest> items;
    
    @NotBlank(message = "支付方式不能为空")
    private String paymentMethod;
    
    private String remark;
    
    @Valid
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class OrderItemRequest {
        @NotNull(message = "商品ID不能为空")
        private Long productId;
        
        @Min(value = 1, message = "数量必须大于0")
        private Integer quantity;
        
        @DecimalMin(value = "0.01", message = "价格必须大于0")
        private BigDecimal price;
    }
}

/**
 * 统一响应模型
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ApiResponse<T> {
    
    private boolean success;
    private String message;
    private T data;
    private String timestamp;
    private String traceId;
    
    public static <T> ApiResponse<T> success(T data) {
        return ApiResponse.<T>builder()
                .success(true)
                .data(data)
                .timestamp(Instant.now().toString())
                .build();
    }
    
    public static <T> ApiResponse<T> success(T data, String message) {
        return ApiResponse.<T>builder()
                .success(true)
                .message(message)
                .data(data)
                .timestamp(Instant.now().toString())
                .build();
    }
    
    public static <T> ApiResponse<T> error(String message) {
        return ApiResponse.<T>builder()
                .success(false)
                .message(message)
                .timestamp(Instant.now().toString())
                .build();
    }
}

/**
 * 分页结果模型
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PageResult<T> {
    
    private List<T> content;
    private int page;
    private int size;
    private long totalElements;
    private int totalPages;
    private boolean first;
    private boolean last;
    
    public static <T> PageResult<T> of(Page<T> page) {
        return PageResult.<T>builder()
                .content(page.getContent())
                .page(page.getNumber())
                .size(page.getSize())
                .totalElements(page.getTotalElements())
                .totalPages(page.getTotalPages())
                .first(page.isFirst())
                .last(page.isLast())
                .build();
    }
}

@RestController
public class ReportController {
  private final ExecutorService pool = Executors.newFixedThreadPool(8);

  @GetMapping("/reports")
  public DeferredResult<ResponseEntity<ApiResp<String>>> gen(){
    DeferredResult<ResponseEntity<ApiResp<String>>> r = new DeferredResult<>(3000L);
    pool.submit(() -> {
      String id = UUID.randomUUID().toString();
      r.setResult(ResponseEntity.ok(new ApiResp<>(0, "ok", id)));
    });
    r.onTimeout(() -> r.setErrorResult(ResponseEntity.status(503).body(new ApiResp<>(1, "timeout", null))));
    return r;
  }
}