package com.javaweb.geo.service.impl;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.stream.Collectors;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.javaweb.common.utils.DateUtils;
import com.javaweb.framework.util.ShiroUtils;
import com.javaweb.geo.domain.*;
import com.javaweb.geo.mapper.*;
import com.javaweb.geo.service.*;
import com.javaweb.geo.vo.ExceptionProjectVo;
import com.javaweb.geotdp.enums.RecordType;
import com.javaweb.system.domain.SysRole;
import com.javaweb.system.domain.SysUser;
import com.javaweb.system.mapper.SysUserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.javaweb.common.core.text.Convert;
import org.springframework.util.ObjectUtils;

/**
 * 项目Service业务层处理
 *
 * @author zmk
 * @date 2022-10-14
 */
@Service
public class ProjectServiceImpl implements IProjectService {
    @Autowired
    private ProjectMapper projectMapper;

    @Autowired
    private HandleExceptionMapper handleExceptionMapper;

    @Autowired
    private SysUserMapper sysUserMapper;

    @Autowired
    private HoleMapper holeMapper;

    @Autowired
    private HoleBiaoguanMapper holeBiaoguanMapper;

    @Autowired
    private HoleHuiciMapper holeHuiciMapper;

    @Autowired
    private HolePersonMapper holePersonMapper;

    @Autowired
    private HoleQutuMapper holeQutuMapper;

    @Autowired
    private HoleShuiweiMapper holeShuiweiMapper;

    @Autowired
    private HoleYantuMapper holeYantuMapper;

    /**
     * 查询项目
     *
     * @param ids 项目ID
     * @return 项目
     */
    @Override
    public Project selectProjectById(String ids) {
        return projectMapper.selectProjectById(ids);
    }

    /**
     * 查询项目列表
     *
     * @param project 项目
     * @return 项目
     */
    @Override
    public List<Project> selectProjectList(Project project) {
        //return projectMapper.selectProjectList(project);
        List<Project> resultList = new ArrayList<>();

        SysUser sysUser = ShiroUtils.getSysUser();
        List<SysRole> roles = sysUser.getRoles();

        if (!ObjectUtils.isEmpty(roles)) {
            LinkedHashSet<String> collect = roles.stream().map(SysRole::getRoleKey).collect(Collectors.toCollection(LinkedHashSet::new));

            // 管理员角色
            if (collect.contains(RecordType.role_admin.getId())) {
                resultList = projectMapper.selectProjectList(project);
            }
            // 普通角色
            if (collect.contains(RecordType.role_gongsi.getId())) {
                SysUser u = sysUserMapper.selectUserById(sysUser.getUserId());
                project.setCompanyId(u.getCompanyId());
                resultList = projectMapper.selectProjectList(project);
            }

        }

        return resultList;
    }

    /**
     * 新增项目
     *
     * @param project 项目
     * @return 结果
     */
    @Override
    public int insertProject(Project project) {
        project.setCreateTime(DateUtils.getNowDate());
        return projectMapper.insertProject(project);
    }

    /**
     * 修改项目
     *
     * @param project 项目
     * @return 结果
     */
    @Override
    public int updateProject(Project project) {
        return projectMapper.updateProject(project);
    }

    /**
     * 删除项目对象
     *
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteProjectByIds(String ids) {
        return projectMapper.deleteProjectByIds(Convert.toStrArray(ids));
    }

    /**
     * 删除项目信息
     *
     * @param ids 项目ID
     * @return 结果
     */
    @Override
    public int deleteProjectById(String ids) {

        // 删除项目关联的钻孔数据
        String[] strings = Convert.toStrArray(ids);
        if (!ObjectUtils.isEmpty(strings)) {
            for (String projectId : strings) {

                // =======钻孔==========
                List<Hole> holes = holeMapper.selectHoleByProjectId(projectId);
                String[] holeIds = holes.stream().map(Hole::getIds).toArray(String[]::new);

                // =======标贯==========
                List<HoleBiaoguan> biaoguans = holeBiaoguanMapper.selectHoleBiaoguanByProjectId(projectId);
                String[] biaoguanIds = biaoguans.stream().map(HoleBiaoguan::getIds).toArray(String[]::new);

                // =======回次==========
                List<HoleHuici> holeHuicis = holeHuiciMapper.selectHoleHuiciByProjectId(projectId);
                String[] huiCiIds = holeHuicis.stream().map(HoleHuici::getIds).toArray(String[]::new);

                // =======人员==========
                List<HolePerson> persons = holePersonMapper.selectHolePersonByProjectId(projectId);
                String[] personIds = persons.stream().map(HolePerson::getIds).toArray(String[]::new);

                // =======取土==========
                List<HoleQutu> qutus = holeQutuMapper.selectHoleQutuByProjectId(projectId);
                String[] qutuIds = qutus.stream().map(HoleQutu::getIds).toArray(String[]::new);

                // =======水位==========
                List<HoleShuiwei> shuiweis = holeShuiweiMapper.selectHoleShuiWeiByProjectId(projectId);
                String[] shuiweiIds = shuiweis.stream().map(HoleShuiwei::getIds).toArray(String[]::new);

                // =======岩土==========
                List<HoleYantu> yantus = holeYantuMapper.selectHoleYantuByProjectId(projectId);
                String[] yantusIds = yantus.stream().map(HoleYantu::getIds).toArray(String[]::new);

                holeMapper.deleteHoleByIds(holeIds);
                holeBiaoguanMapper.deleteHoleBiaoguanByIds(biaoguanIds);
                holeHuiciMapper.deleteHoleHuiciByIds(huiCiIds);
                holePersonMapper.deleteHolePersonByIds(personIds);
                holeQutuMapper.deleteHoleQutuByIds(qutuIds);
                holeShuiweiMapper.deleteHoleShuiweiByIds(shuiweiIds);
                holeYantuMapper.deleteHoleYantuByIds(yantusIds);
            }
        }

        return projectMapper.deleteProjectById(ids);
    }

    /**
     * 查询异常项目列表
     */
    @Override
    public List<ExceptionProjectVo> proExceptionList() {

        List<Project> list = projectMapper.proExceptionList();

        List<ExceptionProjectVo> resultList = new ArrayList<>();
        ExceptionProjectVo item;

        if (ObjectUtil.isNotEmpty(list)) {
            for (Project project : list) {
                item = new ExceptionProjectVo();
                BeanUtil.copyProperties(project, item);

                List<HandleException> exceptionList = handleExceptionMapper.selectListByProjectId(project.getIds());

                String holeCodes = "", time = "";
                if (ObjectUtil.isNotEmpty(exceptionList)) {
                    holeCodes = exceptionList.stream().map(HandleException::getHoleCode).collect(Collectors.joining(",", "", ""));
                    time = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, exceptionList.get(0).getMapTime()) + "~" + DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, exceptionList.get(exceptionList.size() - 1).getMapTime());
                }

                item.setExceptionNum(exceptionList.size());
                item.setHoleCodes(holeCodes);
                item.setTime(time);
                resultList.add(item);
            }
        }
        return resultList;
    }
}