package com.ygtx.web.util;

import com.ygtx.common.core.domain.ice.IcePendingTaskRequest;
import com.ygtx.common.core.domain.ice.IcePendingTaskResponse;
import com.ygtx.common.core.domain.ice.IcePendingTaskStatusRequest;
import com.ygtx.common.utils.StringUtils;
import com.ygtx.web.service.IcePendingTaskService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

/**
 * ICE待办任务辅助工具类
 * 提供便捷的方法来推送待办任务和更新任务状态
 *
 * @author ygt
 */
@Component
public class IcePendingTaskHelper
{
    private static final Logger log = LoggerFactory.getLogger(IcePendingTaskHelper.class);

    @Autowired
    private IcePendingTaskService icePendingTaskService;

    /**
     * 推送待办任务
     *
     * @param title 任务标题
     * @param summary 任务摘要
     * @param content 任务内容
     * @param userCode 用户工号
     * @param url 跳转链接
     * @return 任务ID，推送失败返回null
     */
    public String sendPendingTask(String title, String summary, String content, String userCode, String url)
    {
        return sendPendingTask(title, summary, content, userCode, url, null);
    }

    /**
     * 推送待办任务
     *
     * @param title 任务标题
     * @param summary 任务摘要
     * @param content 任务内容
     * @param userCode 用户工号
     * @param url 跳转链接
     * @param customTaskId 自定义任务ID，如果为null则自动生成
     * @return 任务ID，推送失败返回null
     */
    public String sendPendingTask(String title, String summary, String content, String userCode, String url, String customTaskId)
    {
        if (StringUtils.isEmpty(title) || StringUtils.isEmpty(userCode) || StringUtils.isEmpty(url))
        {
            log.error("推送待办任务失败，必要参数不能为空：title={}, userCode={}, url={}", title, userCode, url);
            return null;
        }

        try
        {
            IcePendingTaskRequest request = new IcePendingTaskRequest();
            request.setTitle(title);
            request.setSumary(summary);
            request.setContent(content);
            request.setCode(userCode);
            request.setUrl(url);
            request.setTaskId(StringUtils.isEmpty(customTaskId) ? generateTaskId() : customTaskId);
            request.setIsCompleted("1"); // 待办状态
            
            IcePendingTaskResponse response = icePendingTaskService.sendPendingTask(request);
            
            if (response.getSuccess())
            {
                log.info("成功推送待办任务，标题：{}，用户：{}，任务ID：{}", title, userCode, request.getTaskId());
                return request.getTaskId();
            }
            else
            {
                log.error("推送待办任务失败，标题：{}，用户：{}，错误：{}", title, userCode, response.getMsg());
                return null;
            }
        }
        catch (Exception e)
        {
            log.error("推送待办任务异常，标题：" + title + "，用户：" + userCode, e);
            return null;
        }
    }

    /**
     * 完成待办任务（更新为已办状态）
     *
     * @param taskId 任务ID
     * @param systemId 系统ID
     * @return 操作是否成功
     */
    public boolean completePendingTask(String taskId, String systemId)
    {
        return updatePendingTaskStatus(taskId, "2", systemId);
    }

    /**
     * 将待办任务标记为处理中（仍为待办状态）
     *
     * @param taskId 任务ID
     * @param systemId 系统ID
     * @return 操作是否成功
     */
    public boolean markPendingTaskAsProcessing(String taskId, String systemId)
    {
        return updatePendingTaskStatus(taskId, "1", systemId);
    }

    /**
     * 更新待办任务状态
     *
     * @param taskId 任务ID
     * @param status 状态（1-待办，2-已办）
     * @param systemId 系统ID
     * @return 操作是否成功
     */
    public boolean updatePendingTaskStatus(String taskId, String status, String systemId)
    {
        if (StringUtils.isEmpty(taskId) || StringUtils.isEmpty(status) || StringUtils.isEmpty(systemId))
        {
            log.error("更新待办任务状态失败，参数不能为空：taskId={}, status={}, systemId={}", taskId, status, systemId);
            return false;
        }

        try
        {
            IcePendingTaskStatusRequest request = new IcePendingTaskStatusRequest();
            request.setTaskId(taskId);
            request.setIsCompleted(status);
            request.setSystemId(systemId);

            IcePendingTaskResponse response = icePendingTaskService.updatePendingTaskStatus(request);

            if (response.getSuccess())
            {
                log.info("成功更新待办任务状态，任务ID：{}，新状态：{}，系统ID：{}", taskId, status, systemId);
                return true;
            }
            else
            {
                log.error("更新待办任务状态失败，任务ID：{}，目标状态：{}，错误：{}", taskId, status, response.getMsg());
                return false;
            }
        }
        catch (Exception e)
        {
            log.error("更新待办任务状态异常，任务ID：" + taskId + "，目标状态：" + status, e);
            return false;
        }
    }

    /**
     * 取消待办任务
     *
     * @param taskId 任务ID
     * @param systemId 系统ID
     * @return 操作是否成功
     */
    public boolean cancelPendingTask(String taskId, String systemId)
    {
        if (StringUtils.isEmpty(taskId) || StringUtils.isEmpty(systemId))
        {
            log.error("取消待办任务失败，参数不能为空：taskId={}, systemId={}", taskId, systemId);
            return false;
        }

        try
        {
            IcePendingTaskResponse response = icePendingTaskService.cancelPendingTask(taskId, systemId);

            if (response.getSuccess())
            {
                log.info("成功取消待办任务，任务ID：{}，系统ID：{}", taskId, systemId);
                return true;
            }
            else
            {
                log.error("取消待办任务失败，任务ID：{}，系统ID：{}，错误：{}", taskId, systemId, response.getMsg());
                return false;
            }
        }
        catch (Exception e)
        {
            log.error("取消待办任务异常，任务ID：" + taskId + "，系统ID：" + systemId, e);
            return false;
        }
    }

    /**
     * 生成任务ID
     *
     * @return 任务ID
     */
    private String generateTaskId()
    {
        return "task_" + UUID.randomUUID().toString().replace("-", "");
    }
}