package com.ruoyi.safe.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.basic.enums.ApplicationTypeEnum;
import com.ruoyi.basic.enums.RecordTypeEnum;
import com.ruoyi.basic.utils.FileUtil;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.safe.dto.SafeLineInspectionExecuteDto;
import com.ruoyi.safe.pojo.SafeLineInspection;
import com.ruoyi.safe.mapper.SafeLineInspectionMapper;
import com.ruoyi.safe.pojo.SafeLineInspectionHazard;
import com.ruoyi.safe.pojo.SafeLineInspectionRecord;
import com.ruoyi.safe.pojo.SafeHidden;
import com.ruoyi.safe.service.SafeHiddenService;
import com.ruoyi.safe.service.SafeLineInspectionHazardService;
import com.ruoyi.safe.service.SafeLineInspectionRecordService;
import com.ruoyi.safe.service.SafeLineInspectionService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.project.system.mapper.SysUserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 安全生产--线路巡检任务 服务实现类
 * </p>
 *
 * @author 芯导软件（江苏）有限公司
 * @since 2026-06-29
 */
@Service
public class SafeLineInspectionServiceImpl extends ServiceImpl<SafeLineInspectionMapper, SafeLineInspection> implements SafeLineInspectionService {

    @Autowired
    private SysUserMapper sysUserMapper;
    @Autowired
    private SafeLineInspectionRecordService safeLineInspectionRecordService;
    @Autowired
    private SafeLineInspectionHazardService safeLineInspectionHazardService;
    @Autowired
    private SafeHiddenService safeHiddenService;
    @Autowired
    private FileUtil fileUtil;

    @Override
    public IPage<SafeLineInspection> pageSafeLineInspection(Page page, SafeLineInspection safeLineInspection) {
        IPage<SafeLineInspection> result = this.lambdaQuery()
                .eq(safeLineInspection.getScheduleTaskId() != null, SafeLineInspection::getScheduleTaskId, safeLineInspection.getScheduleTaskId())
                .like(StringUtils.isNotBlank(safeLineInspection.getInspectionCode()), SafeLineInspection::getInspectionCode, safeLineInspection.getInspectionCode())
                .like(StringUtils.isNotBlank(safeLineInspection.getInspectionName()), SafeLineInspection::getInspectionName, safeLineInspection.getInspectionName())
                .like(StringUtils.isNotBlank(safeLineInspection.getLineName()), SafeLineInspection::getLineName, safeLineInspection.getLineName())
                .like(StringUtils.isNotBlank(safeLineInspection.getInspectionProject()), SafeLineInspection::getInspectionProject, safeLineInspection.getInspectionProject())
                .eq(StringUtils.isNotBlank(safeLineInspection.getStatus()), SafeLineInspection::getStatus, safeLineInspection.getStatus())
                .orderByDesc(SafeLineInspection::getCreateTime)
                .page(page);

        // 关联查询巡检人名称
        fillInspectorName(result.getRecords());

        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean executeInspection(SafeLineInspectionExecuteDto executeDto) {
        if (executeDto == null || executeDto.getInspectionId() == null) {
            throw new IllegalArgumentException("巡检记录不能为空");
        }
        SafeLineInspection inspection = this.getById(executeDto.getInspectionId());
        if (inspection == null) {
            throw new IllegalArgumentException("巡检记录不存在");
        }
        if ("已完成".equals(inspection.getStatus())) {
            throw new IllegalArgumentException("巡检记录已完成，请勿重复执行");
        }
        if (!"正常".equals(executeDto.getCheckResult()) && !"异常".equals(executeDto.getCheckResult())) {
            throw new IllegalArgumentException("请选择巡检结果");
        }

        LocalDateTime checkTime = executeDto.getCheckTime() == null ? LocalDateTime.now() : executeDto.getCheckTime();
        SafeLineInspectionRecord record = buildInspectionRecord(inspection, executeDto, checkTime);
        safeLineInspectionRecordService.save(record);

        inspection.setInspectionResult(executeDto.getCheckResult());
        inspection.setActualInspectionTime(checkTime);
        inspection.setUpdateTime(LocalDateTime.now());
        inspection.setUpdateUser(SecurityUtils.getUserId().intValue());
        appendCurrentInspector(inspection);

        if ("异常".equals(executeDto.getCheckResult())) {
            validateHazard(executeDto);
            SafeHidden hidden = createSafeHidden(executeDto);
            safeHiddenService.add(hidden);
            fileUtil.saveStorageAttachment(
                    ApplicationTypeEnum.IMAGE,
                    RecordTypeEnum.SAFE_HIDDEN,
                    hidden.getId().longValue(),
                    executeDto.getStorageBlobDTOs()
            );

            SafeLineInspectionHazard hazard = buildLineHazard(inspection, record, hidden, executeDto);
            safeLineInspectionHazardService.save(hazard);

            inspection.setHiddenId(hidden.getId());
            inspection.setStatus("待整改");
        } else {
            inspection.setHiddenId(null);
            inspection.setStatus("已完成");
        }

        return this.updateById(inspection);
    }

    private SafeLineInspectionRecord buildInspectionRecord(SafeLineInspection inspection,
                                                           SafeLineInspectionExecuteDto executeDto,
                                                           LocalDateTime checkTime) {
        SafeLineInspectionRecord record = new SafeLineInspectionRecord();
        record.setInspectionId(inspection.getId());
        record.setCheckPoint(inspection.getLineName());
        record.setCheckContent(inspection.getInspectionProject());
        record.setCheckResult(executeDto.getCheckResult());
        record.setCheckDesc("异常".equals(executeDto.getCheckResult()) ? null : executeDto.getCheckDesc());
        record.setCheckTime(checkTime);
        record.setStorageBlobDTOs(executeDto.getStorageBlobDTOs());
        return record;
    }

    private void validateHazard(SafeLineInspectionExecuteDto executeDto) {
        if (executeDto.getStorageBlobDTOs() == null || executeDto.getStorageBlobDTOs().isEmpty()) {
            throw new IllegalArgumentException("巡检异常时请上传异常照片");
        }
        if (StringUtils.isBlank(executeDto.getHiddenType())) {
            throw new IllegalArgumentException("请选择隐患类型");
        }
        if (StringUtils.isBlank(executeDto.getRiskLevel())) {
            throw new IllegalArgumentException("请选择隐患风险等级");
        }
        if (StringUtils.isBlank(executeDto.getHazardLocation())) {
            throw new IllegalArgumentException("请输入隐患位置");
        }
        if (StringUtils.isBlank(executeDto.getHazardDesc())) {
            throw new IllegalArgumentException("请输入异常描述/整改要求");
        }
        if (executeDto.getRectifyUserId() == null) {
            throw new IllegalArgumentException("请选择整改责任人");
        }
        if (executeDto.getRectifyTime() == null) {
            throw new IllegalArgumentException("请选择整改完成期限");
        }
    }

    private SafeHidden createSafeHidden(SafeLineInspectionExecuteDto executeDto) {
        SafeHidden hidden = new SafeHidden();
        hidden.setType(executeDto.getHiddenType());
        hidden.setRiskLevel(executeDto.getRiskLevel());
        hidden.setLocation(executeDto.getHazardLocation());
        hidden.setHiddenDesc(executeDto.getHazardDesc());
        hidden.setRectifyUserId(executeDto.getRectifyUserId());
        hidden.setRectifyUserMobile(executeDto.getRectifyUserMobile());
        hidden.setRectifyTime(executeDto.getRectifyTime());
        return hidden;
    }

    private SafeLineInspectionHazard buildLineHazard(SafeLineInspection inspection,
                                                     SafeLineInspectionRecord record,
                                                     SafeHidden hidden,
                                                     SafeLineInspectionExecuteDto executeDto) {
        SafeLineInspectionHazard hazard = new SafeLineInspectionHazard();
        hazard.setInspectionId(inspection.getId());
        hazard.setRecordId(record.getId());
        hazard.setSafeHiddenId(hidden.getId());
        hazard.setHazardCode(hidden.getHiddenCode());
        hazard.setHazardDesc(executeDto.getHazardDesc());
        hazard.setHazardLevel(executeDto.getRiskLevel());
        hazard.setHazardLocation(executeDto.getHazardLocation());
        hazard.setStatus("待整改");
        hazard.setRectifyUserId(executeDto.getRectifyUserId());
        hazard.setRectifyDeadline(executeDto.getRectifyTime());
        return hazard;
    }

    private void appendCurrentInspector(SafeLineInspection inspection) {
        Long currentUserId = SecurityUtils.getUserId();
        if (currentUserId == null) {
            return;
        }
        String currentUserIdStr = String.valueOf(currentUserId);
        String inspectorId = inspection.getInspectorId();
        if (StringUtils.isBlank(inspectorId)) {
            inspection.setInspectorId(currentUserIdStr);
            return;
        }
        boolean exists = Arrays.stream(inspectorId.split(","))
                .map(String::trim)
                .anyMatch(currentUserIdStr::equals);
        if (!exists) {
            inspection.setInspectorId(inspectorId + "," + currentUserIdStr);
        }
    }

    /**
     * 填充巡检人名称（支持多巡检人，逗号分隔）
     */
    private void fillInspectorName(List<SafeLineInspection> records) {
        if (records == null || records.isEmpty()) {
            return;
        }

        // 收集所有巡检人ID（处理逗号分隔的多个ID）
        List<Long> allInspectorIds = records.stream()
                .map(SafeLineInspection::getInspectorId)
                .filter(ids -> ids != null && !ids.isEmpty())
                .flatMap(ids -> Arrays.stream(ids.split(",")))
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .map(Long::parseLong)
                .distinct()
                .collect(Collectors.toList());

        if (allInspectorIds.isEmpty()) {
            return;
        }

        // 批量查询用户信息
        List<SysUser> users = sysUserMapper.selectUserByIds(allInspectorIds);
        Map<Long, String> userMap = users.stream()
                .collect(Collectors.toMap(SysUser::getUserId, SysUser::getNickName, (v1, v2) -> v1));

        // 设置巡检人名称
        for (SafeLineInspection record : records) {
            if (record.getInspectorId() != null && !record.getInspectorId().isEmpty()) {
                String inspectorNames = Arrays.stream(record.getInspectorId().split(","))
                        .map(String::trim)
                        .filter(s -> !s.isEmpty())
                        .map(idStr -> {
                            try {
                                Long id = Long.parseLong(idStr);
                                return userMap.getOrDefault(id, "未知用户");
                            } catch (NumberFormatException e) {
                                return "未知用户";
                            }
                        })
                        .collect(Collectors.joining(","));
                record.setInspectorName(inspectorNames);
            }
        }
    }
}