package com.chinaztt.mes.production.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.chinaztt.mes.basic.entity.Workstation;
import com.chinaztt.mes.basic.mapper.WorkstationMapper;
import com.chinaztt.mes.production.dto.OperationTaskDTO;
import com.chinaztt.mes.production.dto.PersonBoardDTO;
import com.chinaztt.mes.production.dto.WorkstationDTO;
import com.chinaztt.mes.production.entity.JoinPersonHandyman;
import com.chinaztt.mes.production.entity.PersonBoard;
import com.chinaztt.mes.production.mapper.HandymanTableMapper;
import com.chinaztt.mes.production.mapper.JoinPersonHandymanMapper;
import com.chinaztt.mes.production.mapper.OperationTaskMapper;
import com.chinaztt.mes.production.mapper.PersonBoardMapper;
import com.chinaztt.mes.production.service.PersonBoardService;
import lombok.AllArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 人员上机
 *
 * @author cxf
 * @date 2020-11-04 15:36:55
 */
@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class PersonBoardServiceImpl extends ServiceImpl<PersonBoardMapper, PersonBoard> implements PersonBoardService {
    private WorkstationMapper workstationMapper;
    private OperationTaskMapper operationTaskMapper;
    private HandymanTableMapper handymanTableMapper;
    private JoinPersonHandymanMapper joinPersonHandymanMapper;

    @Override
    public JSONObject selectByWorkstationId(Long workstationId) {
        JSONObject jsonObject = new JSONObject();
        // 1.查上机人员
        jsonObject.putOpt("personBoardList", baseMapper.selectDtoByParam(null, workstationId, null));
        // 2.查杂工
        jsonObject.putOpt("handymanTableList", handymanTableMapper.selectByWorkstationId(workstationId));
        return jsonObject;
    }

    @Override
    public boolean deleteByIds(List<Long> ids) {
        ids.forEach(id -> {
            // 删除要判断一下，是否已经登记了杂工
            if (CollectionUtil.isNotEmpty(joinPersonHandymanMapper.selectList(Wrappers.<JoinPersonHandyman>query().lambda().eq(JoinPersonHandyman::getPersonBoardId, id)))) {
                throw new RuntimeException("请先删除对应登记杂工再删除上机人员：" + baseMapper.selectDtoById(id).getStaffName());
            }
        });
        return SqlHelper.retBool(baseMapper.deleteBatchIds(ids));
    }

    @Override
    public void checkRepeatWork(PersonBoard personBoard) {
        List<PersonBoardDTO> result = baseMapper.selectDtoByParam(personBoard.getId(), personBoard.getWorkstationId(), personBoard.getStaffId());
        if (CollectionUtil.isNotEmpty(result)) {
            throw new RuntimeException("上班人员重复：" + result.get(0).getStaffName());
        }
        if (personBoard.getWorkTime() == null) {
            personBoard.setWorkTime(LocalDateTime.now());
        }
    }

    @Override
    public boolean closingByIds(List<Long> ids) {
        PersonBoard personBoard = new PersonBoard();
        personBoard.setClosingTime(LocalDateTime.now());
        personBoard.setStatus("02closing");
        return SqlHelper.retBool(baseMapper.update(personBoard, Wrappers.<PersonBoard>query().lambda().in(PersonBoard::getId, ids)));
    }

    @Override
    public PersonBoardDTO getDtoById(Long id) {
        PersonBoardDTO personBoardDTO = baseMapper.selectDtoById(id);
        if (personBoardDTO == null) {
            throw new RuntimeException("人员上机记录不存在");
        }
        return personBoardDTO;
    }

    @Override
    public List<WorkstationDTO> workstationList() {
        List<Workstation> workstations = workstationMapper.selectList(null);
        List<WorkstationDTO> list = new ArrayList<>();
        if (CollectionUtil.isNotEmpty(workstations)) {
            for (Workstation ws : workstations) {
                WorkstationDTO dto = new WorkstationDTO();
                dto.setId(ws.getId());
                dto.setName(ws.getName());
                dto.setNumber(ws.getWorkstationNo());

                List<PersonBoardDTO> staffList = baseMapper.selectDtoByParam(null, ws.getId(), null);
                dto.setStaffCount(staffList == null ? 0 : staffList.size());

                List<OperationTaskDTO> taskList = operationTaskMapper.getListByWorkstationId(ws.getId());
                dto.setTaskList(taskList);

                list.add(dto);
            }
        }
        return list;
    }

    @Override
    public PersonBoardDTO updateDutyTimeById(PersonBoardDTO personBoardDTO) {
        baseMapper.updateById(personBoardDTO);
        return baseMapper.getPersonDtoById(personBoardDTO.getId());
    }

    @Override
    public List<Long> saveList(List<PersonBoard> personBoardList) {
        List<Long> ids = new ArrayList<Long>();
        for (PersonBoard personBoard : personBoardList) {
            baseMapper.insert(personBoard);
            ids.add(personBoard.getId());
        }
        return ids;
    }


    @Override
    public String checkPersonHaveToWork(List<PersonBoard> personBoardList) {
        String msg = "";
        for (PersonBoard personBoard : personBoardList) {
            List<PersonBoardDTO> list = baseMapper.checkPersonHaveToWork(personBoard);
            if (CollectionUtil.isNotEmpty(list)) {
                for (PersonBoardDTO personBoardDTO : list) {
                    msg += personBoardDTO.getStaffName() + "：" + personBoardDTO.getNowDutyDate() + "/" + personBoardDTO.getWorkstationName() + "已出勤，";
                }
            }
        }
        return msg;
    }

	@Override
	public List<Long> batchSave(List<PersonBoard> personBoardList) {
		List<PersonBoard> boards = new ArrayList<>();
		// 找出工作站
		Workstation workstation = workstationMapper.selectById(personBoardList.get(0).getWorkstationId());
		// 找出该工作站的工作重心关联的所有工作站
		List<Workstation> workstationList = workstationMapper.selectList(Wrappers.<Workstation>query().lambda().eq(Workstation::getWorkCenter, workstation.getWorkCenter()));

		for (Workstation station : workstationList) {
			// 循环生成所有工作站人员上机记录
			for (PersonBoard personBoard : personBoardList) {
				PersonBoard newBoard = new PersonBoard();
				BeanUtils.copyProperties(personBoard, newBoard);
				newBoard.setWorkstationId(station.getId());
				newBoard.setDutyRecordId(station.getDutyRecordId());
				int count = this.count(Wrappers.<PersonBoard>lambdaQuery()
						.eq(PersonBoard::getDutyRecordId, newBoard.getDutyRecordId())
						.eq(PersonBoard::getStaffId, newBoard.getStaffId())
						.eq(PersonBoard::getWorkstationId, newBoard.getWorkstationId()));
				if (count == 0) {
					boards.add(newBoard);
				}
			}
		}
		this.saveBatch(boards);
		return boards.stream().map(PersonBoard::getId).collect(Collectors.toList());
	}
}