package com.designhub.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.designhub.common.Result;
import com.designhub.dto.TaskAssignRequest;
import com.designhub.dto.TaskAuditRequest;
import com.designhub.entity.Task;
import com.designhub.service.TaskService;
import com.designhub.util.JwtUtil;
import com.designhub.vo.DashboardStatsVO;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

/**
 * 任务管理控制器
 */
@Slf4j
@Tag(name = "任务管理", description = "任务的增删改查、抢单、审核等接口")
@RestController
@RequestMapping("/api/tasks")
@RequiredArgsConstructor
public class TaskController {

    private final TaskService taskService;
    private final JwtUtil jwtUtil;

    @Operation(summary = "创建任务", description = "发起新的设计任务")
    @PostMapping
    public Result<Long> createTask(@RequestBody Task task, @RequestHeader("Authorization") String authHeader) {
        log.info("创建任务: {}", task.getTitle());
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        task.setPublisherId(userId);
        Long taskId = taskService.createTask(task);
        return Result.success(taskId);
    }

    @Operation(summary = "创建流水线任务", description = "创建包含多个子任务的流水线任务")
    @PostMapping("/pipeline")
    public Result<Long> createPipelineTask(
            @RequestBody com.designhub.dto.PipelineTaskDTO dto, 
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("创建流水线任务: {}", dto.getTitle());
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        Long taskId = taskService.createPipelineTask(dto, userId);
        return Result.success("流水线任务创建成功", taskId);
    }

    @Operation(summary = "获取任务列表", description = "分页查询任务列表，支持多种筛选条件")
    @GetMapping
    public Result<IPage<Task>> getTaskList(
            @Parameter(description = "任务状态") @RequestParam(required = false) String status,
            @Parameter(description = "任务类型ID") @RequestParam(required = false) Long taskTypeId,
            @Parameter(description = "页码") @RequestParam(defaultValue = "1") Integer page,
            @Parameter(description = "每页数量") @RequestParam(defaultValue = "20") Integer pageSize) {
        
        log.info("查询任务列表: status={}, taskTypeId={}, page={}, pageSize={}", 
                status, taskTypeId, page, pageSize);
        
        IPage<Task> taskPage = taskService.getTaskList(page, pageSize, status, taskTypeId);
        return Result.success(taskPage);
    }

    @Operation(summary = "获取所有待审核任务", description = "获取所有处于审批流程中的任务（包括需求部门审核和接单部门审核）")
    @GetMapping("/pending-approval-all")
    public Result<IPage<Task>> getAllPendingApprovalTasks(
            @Parameter(description = "任务类型ID") @RequestParam(required = false) Long taskTypeId,
            @Parameter(description = "页码") @RequestParam(defaultValue = "1") Integer page,
            @Parameter(description = "每页数量") @RequestParam(defaultValue = "20") Integer pageSize) {
        
        log.info("查询所有待审核任务: taskTypeId={}, page={}, pageSize={}", 
                taskTypeId, page, pageSize);
        
        IPage<Task> taskPage = taskService.getAllPendingApprovalTasks(page, pageSize, taskTypeId);
        return Result.success(taskPage);
    }

    @Operation(summary = "获取任务详情", description = "根据任务ID获取详细信息")
    @GetMapping("/{id}")
    public Result<Task> getTaskById(@PathVariable Long id) {
        log.info("查询任务详情: {}", id);
        Task task = taskService.getTaskById(id);
        return Result.success(task);
    }

    @Operation(summary = "更新任务", description = "更新任务信息")
    @PutMapping("/{id}")
    public Result<String> updateTask(@PathVariable Long id, @RequestBody Task task) {
        log.info("更新任务: {}", id);
        taskService.updateTask(id, task);
        return Result.success("更新成功");
    }

    @Operation(summary = "抢单", description = "设计师抢单")
    @PostMapping("/{id}/grab")
    public Result<String> grabTask(@PathVariable Long id, @RequestHeader("Authorization") String authHeader) {
        log.info("抢单: {}", id);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        taskService.grabTask(id, userId);
        return Result.success("抢单成功");
    }

    @Operation(summary = "提交任务", description = "设计师提交完成的任务")
    @PostMapping("/{id}/submit")
    public Result<String> submitTask(
            @PathVariable Long id, 
            @RequestParam String deliveryPath,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("提交任务: {}, 交付路径: {}", id, deliveryPath);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        taskService.submitTask(id, userId, deliveryPath);
        return Result.success("提交成功");
    }

    @Operation(summary = "审核任务", description = "需求方审核任务")
    @PostMapping("/{id}/review")
    public Result<String> reviewTask(
            @PathVariable Long id,
            @RequestParam Boolean approved,
            @RequestParam(required = false) String comment,
            @RequestParam(required = false) Integer rating,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("审核任务: {}, 通过: {}, 评分: {}", id, approved, rating);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        taskService.reviewTask(id, userId, approved, comment, rating);
        return Result.success(approved ? "审核通过" : "已驳回");
    }

    @Operation(summary = "取消任务", description = "发布人取消任务")
    @PostMapping("/{id}/cancel")
    public Result<String> cancelTask(
            @PathVariable Long id,
            @RequestParam String reason,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("取消任务: {}, 原因: {}", id, reason);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        taskService.cancelTask(id, userId, reason);
        return Result.success("取消成功");
    }

    @Operation(summary = "获取已完成任务列表", description = "根据用户角色返回不同范围的已完成任务")
    @GetMapping("/completed")
    public Result<IPage<Task>> getCompletedTasks(
            @Parameter(description = "页码") @RequestParam(defaultValue = "1") Integer page,
            @Parameter(description = "每页数量") @RequestParam(defaultValue = "12") Integer pageSize,
            @Parameter(description = "关键词") @RequestParam(required = false) String keyword,
            @Parameter(description = "排序方式") @RequestParam(required = false) String sortBy,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("查询已完成任务: page={}, pageSize={}, keyword={}, sortBy={}", 
                page, pageSize, keyword, sortBy);
        
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        IPage<Task> taskPage = taskService.getCompletedTasks(page, pageSize, userId, keyword, sortBy);
        return Result.success(taskPage);
    }

    @Operation(summary = "任务大厅", description = "获取可接单的任务列表，支持多种筛选、搜索和排序")
    @GetMapping("/hall")
    public Result<IPage<Task>> getTaskHall(
            @Parameter(description = "任务类型ID") @RequestParam(required = false) Long taskTypeId,
            @Parameter(description = "需求类型ID") @RequestParam(required = false) Long demandTypeId,
            @Parameter(description = "品牌ID") @RequestParam(required = false) Long brandId,
            @Parameter(description = "类目ID") @RequestParam(required = false) Long categoryId,
            @Parameter(description = "平台ID") @RequestParam(required = false) Long platformId,
            @Parameter(description = "任务子类型") @RequestParam(required = false) String taskSubType,
            @Parameter(description = "最小积分") @RequestParam(required = false) Integer minScore,
            @Parameter(description = "最大积分") @RequestParam(required = false) Integer maxScore,
            @Parameter(description = "关键词搜索") @RequestParam(required = false) String keyword,
            @Parameter(description = "发布人姓名") @RequestParam(required = false) String publisherName,
            @Parameter(description = "发布时间范围：today/week/month") @RequestParam(required = false) String timeRange,
            @Parameter(description = "排序方式：latest/score/deadline/hot") @RequestParam(required = false) String sortBy,
            @Parameter(description = "页码") @RequestParam(defaultValue = "1") Integer page,
            @Parameter(description = "每页数量") @RequestParam(defaultValue = "20") Integer pageSize) {
        
        log.info("查询任务大厅: taskTypeId={}, demandTypeId={}, brandId={}, categoryId={}, platformId={}, " +
                "taskSubType={}, minScore={}, maxScore={}, keyword={}, publisherName={}, timeRange={}, " +
                "sortBy={}, page={}, pageSize={}", 
                taskTypeId, demandTypeId, brandId, categoryId, platformId, taskSubType, 
                minScore, maxScore, keyword, publisherName, timeRange, sortBy, page, pageSize);
        
        IPage<Task> taskPage = taskService.getTaskHall(page, pageSize, taskTypeId, demandTypeId, 
                brandId, categoryId, platformId, taskSubType, minScore, maxScore, keyword, 
                publisherName, timeRange, sortBy);
        return Result.success(taskPage);
    }

    @Operation(summary = "我的任务", description = "获取当前用户的任务列表")
    @GetMapping("/my")
    public Result<IPage<Task>> getMyTasks(
            @RequestParam(required = false) String role, // publisher 或 receiver
            @RequestParam(required = false) String status,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "20") Integer pageSize,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("查询我的任务: role={}, status={}, page={}, pageSize={}", 
                role, status, page, pageSize);
        
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        IPage<Task> taskPage;
        if ("publisher".equals(role)) {
            taskPage = taskService.getMyPublishedTasks(page, pageSize, userId, status);
        } else {
            taskPage = taskService.getMyReceivedTasks(page, pageSize, userId, status);
        }
        
        return Result.success(taskPage);
    }

    @Operation(summary = "提交任务审核", description = "任务发起人提交任务给部门负责人审核")
    @PostMapping("/{id}/submit-audit")
    public Result<Boolean> submitTaskForAudit(
            @PathVariable Long id,
            @RequestHeader("Authorization") String authHeader) {
        log.info("提交任务审核: taskId={}", id);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        return Result.success(taskService.submitTaskForAudit(id, userId));
    }

    @Operation(summary = "审核任务", description = "部门负责人审核任务（通过或驳回）")
    @PostMapping("/audit")
    public Result<Boolean> auditTask(
            @Valid @RequestBody TaskAuditRequest request,
            @RequestHeader("Authorization") String authHeader) {
        log.info("审核任务: request={}", request);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long auditorId = jwtUtil.getUserIdFromToken(token);
        return Result.success(taskService.auditTask(request, auditorId));
    }

    @Operation(summary = "强制指派任务", description = "部门负责人强制指派任务给部门成员")
    @PostMapping("/assign")
    public Result<Boolean> assignTask(
            @Valid @RequestBody TaskAssignRequest request,
            @RequestHeader("Authorization") String authHeader) {
        log.info("强制指派任务: request={}", request);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long assignerId = jwtUtil.getUserIdFromToken(token);
        return Result.success(taskService.assignTask(request, assignerId));
    }

    @Operation(summary = "负责人任务列表", description = "需求部门负责人查看部门内所有任务")
    @GetMapping("/leader/demand")
    public Result<IPage<Task>> getLeaderTaskList(
            @RequestParam(required = false) String auditStatus,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "20") Integer pageSize,
            @RequestHeader("Authorization") String authHeader) {
        log.info("查询负责人任务列表: auditStatus={}, page={}, pageSize={}", 
                auditStatus, page, pageSize);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        return Result.success(taskService.getLeaderTaskList(userId, page, pageSize, auditStatus));
    }

    @Operation(summary = "接单部门负责人视图", description = "接单部门负责人查看部门成员接单明细")
    @GetMapping("/leader/receiving")
    public Result<IPage<Task>> getLeaderReceivingTaskList(
            @RequestParam(required = false) String status,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "20") Integer pageSize,
            @RequestHeader("Authorization") String authHeader) {
        log.info("查询接单部门负责人视图: status={}, page={}, pageSize={}", 
                status, page, pageSize);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        return Result.success(taskService.getLeaderReceivingTaskList(userId, page, pageSize, status));
    }

    @Operation(summary = "获取工作台统计数据")
    @GetMapping("/dashboard/stats")
    public Result<DashboardStatsVO> getDashboardStats(
            @Parameter(description = "月份，格式：YYYY-MM，不传则查询当月") @RequestParam(required = false) String month,
            @RequestHeader("Authorization") String authHeader) {
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        log.info("获取工作台统计数据: userId={}, month={}", userId, month);
        return Result.success(taskService.getDashboardStats(userId, month));
    }

    @Operation(summary = "获取我的进行中任务")
    @GetMapping("/my-in-progress")
    public Result<java.util.List<Task>> getMyInProgressTasks(@RequestHeader("Authorization") String authHeader) {
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        return Result.success(taskService.getMyInProgressTasks(userId));
    }

    @Operation(summary = "批量更新任务进度")
    @PostMapping("/batch-update-progress")
    public Result<String> batchUpdateProgress(
            @RequestBody java.util.Map<String, Object> payload,
            @RequestHeader("Authorization") String authHeader) {
        
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        @SuppressWarnings("unchecked")
        java.util.List<java.util.Map<String, Object>> updates = 
            (java.util.List<java.util.Map<String, Object>>) payload.get("updates");
        
        taskService.batchUpdateProgress(userId, updates);
        return Result.success("进度更新成功");
    }

    @Operation(summary = "更新任务进度", description = "接单人更新任务进度")
    @PostMapping("/{id}/progress")
    public Result<String> updateTaskProgress(
            @PathVariable Long id,
            @RequestBody java.util.Map<String, Object> payload,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("更新任务进度: taskId={}", id);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        Integer progress = (Integer) payload.get("progress");
        if (progress == null) {
            return Result.error("进度值不能为空");
        }
        
        taskService.updateTaskProgress(id, userId, progress);
        return Result.success("进度更新成功");
    }

    @Operation(summary = "完结任务", description = "接单人完结任务并提交交付路径")
    @PostMapping("/{id}/complete")
    public Result<String> completeTask(
            @PathVariable Long id,
            @RequestBody java.util.Map<String, String> payload,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("完结任务: taskId={}", id);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        String deliveryPath = payload.get("deliveryPath");
        if (deliveryPath == null || deliveryPath.trim().isEmpty()) {
            return Result.error("交付路径不能为空");
        }
        
        taskService.completeTask(id, userId, deliveryPath);
        return Result.success("任务已提交审核");
    }

    @Operation(summary = "审核通过任务", description = "发起人或部门负责人审核通过任务")
    @PostMapping("/{id}/approve")
    public Result<String> approveTask(
            @PathVariable Long id,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("审核通过任务: taskId={}", id);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        taskService.approveTask(id, userId);
        return Result.success("审核通过");
    }

    @Operation(summary = "驳回任务", description = "发起人或部门负责人驳回任务")
    @PostMapping("/{id}/reject")
    public Result<String> rejectTask(
            @PathVariable Long id,
            @RequestBody java.util.Map<String, String> payload,
            @RequestHeader("Authorization") String authHeader) {
        
        log.info("驳回任务: taskId={}", id);
        String token = jwtUtil.extractTokenFromHeader(authHeader);
        Long userId = jwtUtil.getUserIdFromToken(token);
        
        String reason = payload.get("reason");
        if (reason == null || reason.trim().isEmpty()) {
            return Result.error("驳回原因不能为空");
        }
        
        taskService.rejectTask(id, userId, reason);
        return Result.success("任务已驳回");
    }
}