package jnpf.workflow.admin.controller;

import java.util.List;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import jnpf.workflow.admin.result.Result;
import jnpf.workflow.common.exception.ResultCode;
import jnpf.workflow.common.model.fo.CompensateFo;
import jnpf.workflow.common.model.fo.FlowTargetTaskFo;
import jnpf.workflow.common.model.fo.InfoModel;
import jnpf.workflow.common.model.fo.JumpFo;
import jnpf.workflow.common.model.fo.MoveMultiToSingleFo;
import jnpf.workflow.common.model.fo.MoveSingleToMultiFo;
import jnpf.workflow.common.model.fo.TaskAfterFo;
import jnpf.workflow.common.model.fo.TaskBackFo;
import jnpf.workflow.common.model.fo.TaskCompleteFo;
import jnpf.workflow.common.model.fo.TaskNextFo;
import jnpf.workflow.common.model.fo.TaskOutgoingFo;
import jnpf.workflow.common.model.fo.TaskPrevFo;
import jnpf.workflow.common.model.vo.HistoricNodeVo;
import jnpf.workflow.common.model.vo.NodeElementVo;
import jnpf.workflow.common.model.vo.TaskVo;
import jnpf.workflow.common.service.ITaskService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Tag(name = "流程任务控制层", description = "TaskController")
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/Flow/task")
public class TaskController {

    private final ITaskService taskService;

    @Operation(summary = "list", description = "根据流程实例ID获取任务")
    @GetMapping("/list/{instanceId}")
    public Result<List<TaskVo>> list(@PathVariable("instanceId") String instanceId) {
        return Result.success(taskService.getTask(instanceId));
    }

    @Operation(summary = "complete", description = "完成任务")
    @PostMapping("/complete")
    public Result<Boolean> complete(@RequestBody @Valid TaskCompleteFo fo) {
        if (taskService.complete(fo)) {
            return Result.success(ResultCode.COMPLETE_SUCCESS);
        }
        return Result.failed(ResultCode.COMPLETE_FAILURE);
    }

    @Operation(summary = "moveSingleToMulti", description = "单节点跳转多节点")
    @PostMapping("/move/single/to/multi")
    public Result<Boolean> moveSingleToMulti(@RequestBody @Valid MoveSingleToMultiFo fo) {
        if (taskService.moveSingleToMulti(fo)) {
            return Result.success(ResultCode.JUMP_SUCCESS);
        }
        return Result.failed(ResultCode.JUMP_FAILURE);
    }

    @Operation(summary = "moveMultiToSingle", description = "多节点跳转单节点")
    @PostMapping("/move/multi/to/single")
    public Result<Boolean> moveMultiToSingle(@RequestBody @Valid MoveMultiToSingleFo fo) {
        if (taskService.moveMultiToSingle(fo)) {
            return Result.success(ResultCode.JUMP_SUCCESS);
        }
        return Result.failed(ResultCode.JUMP_FAILURE);
    }

    @Operation(summary = "jump", description = "节点跳转")
    @PostMapping("/jump")
    public Result<Boolean> jump(@RequestBody JumpFo fo) {
        if (taskService.jump(fo)) {
            return Result.success(ResultCode.JUMP_SUCCESS);
        }
        return Result.failed(ResultCode.JUMP_FAILURE);
    }

    @Operation(summary = "fallbacks", description = "获取可回退的节点ID")
    @GetMapping("/fallbacks/{taskId}")
    public Result<List<String>> fallbacks(@PathVariable("taskId") String taskId) {
        return Result.success(taskService.getFallbacks(taskId));
    }

    @Operation(summary = "back", description = "退回")
    @PostMapping("/back")
    public Result<List<String>> back(@RequestBody @Valid TaskBackFo fo) {
        return Result.success(taskService.back(fo));
    }

    @Operation(summary = "get", description = "获取上一级任务节点ID集合")
    @GetMapping("/prev")
    public Result<List<String>> getPrev(TaskPrevFo fo) {
        return Result.success(taskService.getPrevUserTask(fo));
    }

    @Operation(summary = "get", description = "获取下一级任务节点集合")
    @GetMapping("/next")
    public Result<List<NodeElementVo>> getNext(TaskNextFo fo) {
        return Result.success(taskService.getNextUserTask(fo));
    }

    @Operation(summary = "retract", description = "撤回")
    @PostMapping("/retract/{taskId}")
    public Result<Boolean> retract(@PathVariable("taskId") String taskId) {
        if (taskService.retract(taskId)) {
            return Result.success(ResultCode.RETRACT_SUCCESS);
        }
        return Result.failed(ResultCode.RETRACT_FAILURE);
    }

    @Operation(summary = "outgoingFlows", description = "获取出线Key集合（若出线的出口为网关，则一并获取网关的出线）")
    @GetMapping("/outgoing/flows")
    public Result<List<String>> getOutgoingFlows(TaskOutgoingFo fo) {
        return Result.success(taskService.getOutgoingFlows(fo));
    }

    @Operation(summary = "get", description = "获取完成的节点Key")
    @GetMapping("/finished/keys/{instanceId}")
    public Result<List<String>> getKeysOfFinished(@PathVariable("instanceId") String instanceId) {
        return Result.success(taskService.getKeysOfFinished(instanceId));
    }

    @Operation(summary = "get", description = "获取进线的Key")
    @GetMapping("/incoming/flows/{taskId}")
    public Result<List<String>> getIncomingFlows(@PathVariable("taskId") String taskId) {
        return Result.success(taskService.getIncomingFlows(taskId));
    }

    @Operation(summary = "get", description = "获取线之后的任务节点")
    @GetMapping("/flow/target")
    public Result<List<String>> getTaskKeyAfterFlow(FlowTargetTaskFo fo) {
        return Result.success(taskService.getTaskKeyAfterFlow(fo));
    }

    @Operation(summary = "get", description = "获取未经过的节点")
    @GetMapping("/tobe/pass/{instanceId}")
    public Result<List<String>> getToBePass(@PathVariable("instanceId") String instanceId) {
        return Result.success(taskService.getToBePass(instanceId));
    }

    @Operation(summary = "get", description = "获取节点的后续节点")
    @PostMapping("/after")
    public Result<List<String>> getAfter(@RequestBody TaskAfterFo fo) {
        return Result.success(taskService.getAfter(fo));
    }

    @Operation(summary = "compensate", description = "异常补偿")
    @PostMapping("/compensate")
    public Result<List<TaskVo>> compensate(@RequestBody CompensateFo fo) {
        return Result.success(taskService.compensate(fo));
    }

    @Operation(summary = "historic", description = "获取历史节点")
    @GetMapping("/historic/{instanceId}")
    public Result<List<HistoricNodeVo>> getHistoric(@PathVariable("instanceId") String instanceId) {
        return Result.success(taskService.getHistoric(instanceId));
    }

    @Operation(summary = "historicEnd", description = "获取历史结束节点")
    @GetMapping("/historic/end/{instanceId}")
    public Result<List<String>> getHistoricEnd(@PathVariable("instanceId") String instanceId) {
        return Result.success(taskService.getHistoricEnd(instanceId));
    }

    @Operation(summary = "elementInfo", description = "获取元素信息")
    @GetMapping("/element/info")
    public Result getElementInfo(InfoModel model) {
        return Result.success(taskService.getElementInfo(model));
    }
}