package com.cmvr.test.service.impl;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cmvr.common.core.domain.entity.SysGroup;
import com.cmvr.test.enums.NodeTypeEnum;
import com.cmvr.test.mapper.TeDetectionItemMapper;
import com.cmvr.test.model.domain.TeDetectionItem;
import com.cmvr.test.model.vo.TeDetectItemDeployFlowVO;
import com.cmvr.test.model.vo.TeDetectionItemVO;
import com.cmvr.test.service.ITeDetectionItemService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * 检测项配置Service业务层处理
 *
 * @author cmvr-iot
 */
@Service
@RequiredArgsConstructor
public class TeDetectionItemServiceImpl extends ServiceImpl<TeDetectionItemMapper, TeDetectionItem> implements ITeDetectionItemService {

    /**
     * 查询检测项配置
     *
     * @param id 检测项配置主键
     * @return 检测项配置
     */
    @Override
    public TeDetectionItem selectTeDetectionItemById(String id) {
        return this.baseMapper.selectById(id);
    }

    /**
     * 查询检测项配置列表
     *
     * @param teDetectionItem 检测项配置
     * @return 检测项配置
     */
    @Override
    public List<TeDetectionItemVO> selectTeDetectionItemList(TeDetectionItem teDetectionItem) {
        MPJLambdaWrapper<TeDetectionItem> queryWrapper = new MPJLambdaWrapper<>();

        queryWrapper.selectAll(TeDetectionItem.class)
                .select(SysGroup::getGroupId)
                .select(SysGroup::getGroupName)
                .leftJoin(SysGroup.class, SysGroup::getGroupId, TeDetectionItem::getGroupId)
                .eq(StrUtil.isNotBlank(teDetectionItem.getSceneCode()), TeDetectionItem::getSceneCode, teDetectionItem.getSceneCode())
                .like(StrUtil.isNotBlank(teDetectionItem.getDetectName()), TeDetectionItem::getDetectName, teDetectionItem.getDetectName())
                .like(StrUtil.isNotBlank(teDetectionItem.getDetectDesc()), TeDetectionItem::getDetectDesc, teDetectionItem.getDetectDesc())
                .eq(StrUtil.isNotBlank(teDetectionItem.getStatus()), TeDetectionItem::getStatus, teDetectionItem.getStatus())
                .eq(StrUtil.isNotBlank(teDetectionItem.getIsDeploy()), TeDetectionItem::getIsDeploy, teDetectionItem.getIsDeploy())
                .eq(StrUtil.isNotBlank(teDetectionItem.getDetectVersion()), TeDetectionItem::getDetectVersion, teDetectionItem.getDetectVersion())
                .orderByDesc(TeDetectionItem::getCreateTime);

        // 执行查询并返回结果
        return this.baseMapper.selectJoinList(TeDetectionItemVO.class, queryWrapper);
    }

    /**
     * 新增检测项配置
     *
     * @param teDetectionItem 检测项配置
     * @return 结果
     */
    @Override
    public int insertTeDetectionItem(TeDetectionItem teDetectionItem) {
        // 新增基础配置 此时状态和部署 皆为不可用
        teDetectionItem.setStatus("1");
        teDetectionItem.setIsDeploy("1");
        return this.baseMapper.insert(teDetectionItem);
    }

    /**
     * 修改检测项配置
     *
     * @param teDetectionItem 检测项配置
     * @return 结果
     */
    @Override
    public int updateTeDetectionItem(TeDetectionItem teDetectionItem) {
        return this.baseMapper.updateById(teDetectionItem);
    }

    /**
     * 部署检测项流程（本质还是修改检测项配置）
     */
    @Override
    @Transactional
    public int deployFlow(TeDetectItemDeployFlowVO teDeployFlowVo) {
        // 校验记录存在
        boolean exists = this.baseMapper
                .exists(new QueryWrapper<TeDetectionItem>()
                        .eq("id", teDeployFlowVo.getId()));

        if (!exists) {
            throw new IllegalArgumentException("ID为" + teDeployFlowVo.getId() + "的检测项不存在!");
        }

        // 保存流程 JSON
        TeDetectionItem updateData = new TeDetectionItem();
        updateData.setId(teDeployFlowVo.getId());
        updateData.setFlowData(teDeployFlowVo.getFlowData());
        //获取params
        JSONObject flow = JSON.parseObject(teDeployFlowVo.getFlowData());
        JSONArray nodeArray = flow.getJSONArray("nodes");
        if (nodeArray == null) {
            throw new IllegalArgumentException("流程图中未找到任何节点");
        }

        for (int i = 0; i < nodeArray.size(); i++) {
            JSONObject nodeJson = nodeArray.getJSONObject(i);
            if (!NodeTypeEnum.START.getCode().equals(nodeJson.getString("type"))) {
                continue;
            }

            JSONObject properties = nodeJson.getJSONObject("properties");
            if (properties == null || !properties.containsKey("inputParams")) {
                continue;
            }

            JSONArray inputParams = properties.getJSONArray("inputParams");
            if (inputParams == null) {
                continue;
            }

            // 移除"terminalId" 的参数
            Iterator<Object> iterator = inputParams.iterator();
            while (iterator.hasNext()) {
                JSONObject param = (JSONObject) iterator.next();
                if ("terminalId".equals(param.getString("name"))) {
                    iterator.remove();
                }
            }

            updateData.setConfig(inputParams.toJSONString());
            break;
        }

        return this.baseMapper.updateById(updateData);
    }

    @Override
    public int publish(String flowId) {
        TeDetectionItem updateData = new TeDetectionItem();
        updateData.setId(flowId);
        updateData.setIsDeploy("0");
        updateData.setStatus("0");
        return this.baseMapper.updateById(updateData);
    }


    /**
     * 批量删除检测项配置
     *
     * @param ids 需要删除的检测项配置主键
     * @return 结果
     */
    @Override
    public int deleteTeDetectionItemByIds(String[] ids) {
        return this.baseMapper.deleteBatchIds(Arrays.asList(ids));
    }

    /**
     * 删除检测项配置信息
     *
     * @param id 检测项配置主键
     * @return 结果
     */
    @Override
    public int deleteTeDetectionItemById(String id) {
        return this.baseMapper.deleteById(id);
    }

    @Override
    public TeDetectionItem selectTeDetectionItemBySceneType(String sceneType) {
        LambdaQueryWrapper<TeDetectionItem> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TeDetectionItem::getSceneCode, sceneType);
        return this.getOne(queryWrapper);
    }
}
