package jnpf.tmsController;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import jnpf.base.ActionResult;
import jnpf.base.vo.PageListVO;
import jnpf.base.vo.PaginationVO;
import jnpf.tmsEntity.task.TmsFromPlanResult;
import jnpf.tmsEntity.task.TmsTaskForm;
import jnpf.tmsEntity.task.TmsTaskQuery;
import jnpf.tmsService.TmsTaskService;
import jnpf.util.JsonUtil;
import lombok.RequiredArgsConstructor;
import jnpf.util.StringUtil;
import org.springframework.web.bind.annotation.DeleteMapping;
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.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * 培训任务管理。网关 /api/tms/task/** （StripPrefix=2）→ /task/**
 */
@Tag(name = "TMS培训任务", description = "Task")
@RestController
@RequestMapping("/task")
@RequiredArgsConstructor
public class TmsTaskController {

    private final TmsTaskService taskService;

    @Operation(summary = "培训任务分页列表")
    @GetMapping("/list")
    public ActionResult<PageListVO<TmsTaskForm>> list(TmsTaskQuery query) {
        List<TmsTaskForm> list = taskService.getList(query);
        PageListVO<TmsTaskForm> vo = new PageListVO<>();
        vo.setList(list);
        vo.setPagination(JsonUtil.getJsonToBean(query, PaginationVO.class));
        return ActionResult.success(vo);
    }

    @Operation(summary = "培训任务详情")
    @GetMapping("/{id}")
    public ActionResult<TmsTaskForm> info(@PathVariable("id") String id) {
        return ActionResult.success(taskService.getInfo(id));
    }

    @Operation(summary = "新增培训任务")
    @PostMapping
    public ActionResult<String> create(@RequestBody TmsTaskForm form) {
        return ActionResult.success(taskService.create(form));
    }

    @Operation(summary = "更新培训任务")
    @PutMapping("/{id}")
    public ActionResult<String> update(@PathVariable("id") String id, @RequestBody TmsTaskForm form) {
        taskService.update(id, form);
        return ActionResult.success("更新成功");
    }

    @Operation(summary = "删除培训任务（仅草稿）")
    @DeleteMapping("/{id}")
    public ActionResult<String> delete(@PathVariable("id") String id) {
        taskService.delete(id);
        return ActionResult.success("删除成功");
    }

    @Operation(summary = "发布培训任务")
    @PutMapping("/{id}/publish")
    public ActionResult<String> publish(@PathVariable("id") String id) {
        taskService.publish(id);
        return ActionResult.success("发布成功");
    }

    @Operation(summary = "取消/终止培训任务")
    @PutMapping("/{id}/cancel")
    public ActionResult<String> cancel(@PathVariable("id") String id) {
        taskService.cancel(id);
        return ActionResult.success("取消成功");
    }

    @Operation(summary = "批量取消培训任务")
    @PutMapping("/cancelBatch")
    public ActionResult<String> cancelBatch(@RequestBody Map<String, List<String>> body) {
        taskService.cancelBatch(body == null ? null : body.get("ids"));
        return ActionResult.success("取消成功");
    }

    @Operation(summary = "恢复为草稿")
    @PutMapping("/{id}/restore")
    public ActionResult<String> restore(@PathVariable("id") String id) {
        taskService.restore(id);
        return ActionResult.success("已恢复为草稿");
    }

    @Operation(summary = "年计划审批通过：按子表生成未发布培训任务")
    @PostMapping("/from-annual/{planId}")
    public ActionResult<TmsFromPlanResult> fromAnnual(@PathVariable("planId") String planId) {
        return ActionResult.success(taskService.createFromAnnual(planId));
    }

    @Operation(summary = "年计划审批通过")
    @PostMapping("/from-annual")
    public ActionResult<TmsFromPlanResult> fromAnnualBody(
            @RequestBody(required = false) Map<String, Object> body,
            @RequestParam(value = "id", required = false) String id,
            @RequestParam(value = "planId", required = false) String planIdParam,
            @RequestParam(value = "f_id", required = false) String fId) {
        Map<String, Object> merged = new LinkedHashMap<>();
        if (body != null) {
            merged.putAll(body);
        }
        // 数据接口预览常把「接口参数」放 query，不进 JSON Body
        putIfAbsent(merged, "id", id);
        putIfAbsent(merged, "planId", planIdParam);
        putIfAbsent(merged, "f_id", fId);
        return ActionResult.success(taskService.createFromAnnual(pickPlanId(merged)));
    }

    @Operation(summary = "岗位培训计划审批通过：按子表生成未发布培训任务")
    @PostMapping("/from-post/{planId}")
    public ActionResult<TmsFromPlanResult> fromPost(@PathVariable("planId") String planId) {
        return ActionResult.success(taskService.createFromPost(planId));
    }

    @Operation(summary = "岗位培训计划审批通过")
    @PostMapping("/from-post")
    public ActionResult<TmsFromPlanResult> fromPostBody(
            @RequestBody(required = false) Map<String, Object> body,
            @RequestParam(value = "id", required = false) String id,
            @RequestParam(value = "planId", required = false) String planIdParam,
            @RequestParam(value = "f_id", required = false) String fId) {
        Map<String, Object> merged = new LinkedHashMap<>();
        if (body != null) {
            merged.putAll(body);
        }
        putIfAbsent(merged, "id", id);
        putIfAbsent(merged, "planId", planIdParam);
        putIfAbsent(merged, "f_id", fId);
        return ActionResult.success(taskService.createFromPost(pickPlanId(merged)));
    }

    private static void putIfAbsent(Map<String, Object> map, String key, String value) {
        if (StringUtil.isEmpty(value)) {
            return;
        }
        Object existed = map.get(key);
        if (existed == null || StringUtil.isEmpty(String.valueOf(existed))
                || "null".equalsIgnoreCase(String.valueOf(existed))
                || "value".equalsIgnoreCase(String.valueOf(existed).trim())) {
            map.put(key, value.trim());
        }
    }

    private static String pickPlanId(Map<String, Object> body) {
        if (body == null || body.isEmpty()) {
            return null;
        }
        for (String key : new String[]{"id", "planId", "f_id", "F_Id", "formId"}) {
            Object v = body.get(key);
            if (v == null) {
                continue;
            }
            String text = String.valueOf(v).trim();
            if (StringUtil.isEmpty(text) || "null".equalsIgnoreCase(text) || "value".equalsIgnoreCase(text)) {
                continue;
            }
            return text;
        }
        return null;
    }
}