package com.chinaztt.mes.production.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.thread.ThreadUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.chinaztt.mes.production.entity.ArtificialInformation;
import com.chinaztt.mes.production.service.ArtificialInformationService;
import com.chinaztt.mes.production.service.DutyRecordService;
import com.chinaztt.mes.production.util.BackUtils;
import com.chinaztt.ztt.common.core.util.R;
import com.chinaztt.ztt.common.log.annotation.SysLog;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


/**
 * 杂工明细
 *
 * @author cxf
 * @date 2021-01-21 13:22:22
 */
@RestController
@AllArgsConstructor
@RequestMapping("/artificialInformation")
@Api(value = "artificialInformation", tags = "杂工明细管理")
public class ArtificialInformationController {

	private final ArtificialInformationService artificialInformationService;
	private final DutyRecordService dutyRecordService;
	private final BackUtils backUtils;

	/**
	 * 分页查询
	 *
	 * @param page                  分页对象
	 * @param artificialInformation 杂工明细
	 * @return
	 */
	@ApiOperation(value = "分页查询", notes = "分页查询")
	@GetMapping("/page")
	public R getProductionArtificialInformationPage(Page page, ArtificialInformation artificialInformation) {
		return R.ok(artificialInformationService.page(page, Wrappers.query(artificialInformation)));
	}

	/**
	 * 根据上班记录查询杂工记录
	 *
	 * @param dutyRecordIdList
	 * @return
	 */
	@ApiOperation(value = "根据上班记录查询杂工记录", notes = "根据上班记录查询杂工记录")
	@GetMapping("/getArtificialInformationByDutyRecordId")
	public R getArtificialInformationByDutyRecordId(@RequestParam("dutyRecordIdList") List<Long> dutyRecordIdList) {
		return R.ok(artificialInformationService.getArtificialInformationByDutyRecordId(dutyRecordIdList));
	}

	/**
	 * 查询工时计算杂工记录
	 *
	 * @param artificialInformation
	 * @returna
	 */
	@ApiOperation(value = "查询工时计算杂工记录", notes = "查询工时计算杂工记录")
	@GetMapping("/getComputationArtificialInformation")
	public R getComputationArtificialInformation(ArtificialInformation artificialInformation) {
		return R.ok(artificialInformationService.getComputationArtificialInformation(artificialInformation));
	}


	/**
	 * 根据班次list，杂工类型查询工时计算杂工记录
	 *
	 * @param dutyRecordIdList
	 * @param handymanTypeId
	 * @returna
	 */
	@ApiOperation(value = "根据班次list，杂工类型查询工时计算杂工记录", notes = "根据班次list，杂工类型查询工时计算杂工记录")
	@GetMapping("/getComputationArtificialInformationByList")
	public R getComputationArtificialInformationByList(@RequestParam("dutyRecordIdList")List<Long> dutyRecordIdList,@RequestParam("handymanTypeId")Long handymanTypeId) {
		return R.ok(artificialInformationService.getComputationArtificialInformationByList(dutyRecordIdList,handymanTypeId));
	}


	/**
	 * 根据上班记录查询人工项目(前端两处要修改)
	 *
	 * @param dutyRecordIdList
	 * @return
	 */
	@ApiOperation(value = "根据上班记录查询人工项目", notes = "根据上班记录查询人工项目")
	@GetMapping("/getHandymanTypeByDutyRecordId")
	public R getHandymanTypeByDutyRecordId(@RequestParam("dutyRecordIdList") List<Long> dutyRecordIdList) {
		return R.ok(artificialInformationService.getHandymanTypeByDutyRecordId(dutyRecordIdList));
	}


	/**
	 * 通过id查询杂工明细
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "通过id查询", notes = "通过id查询")
	@GetMapping("/{id}")
	public R getById(@PathVariable("id") Long id) {
		return R.ok(artificialInformationService.getById(id));
	}

	/**
	 * 批量新增杂工明细
	 *
	 * @param artificialInformationList 杂工明细
	 * @return R
	 */
	@ApiOperation(value = "批量新增杂工明细", notes = "批量新增杂工明细")
	@SysLog("批量新增杂工明细")
	@PostMapping("/batch")
	public R save(@RequestBody List<ArtificialInformation> artificialInformationList) {
		List<Long> ids = artificialInformationService.saveList(artificialInformationList);
		backUtils.backArtificialInformationByIds(ids, "新增");
		if (CollectionUtil.isNotEmpty(artificialInformationList)) {
			Long dutyRecordId = artificialInformationList.get(0).getDutyRecordId();
			ThreadUtil.execute(() -> dutyRecordService.refreshPendingById(dutyRecordId));
		}
		return R.ok(true);
	}

	/**
	 * 新增杂工明细
	 *
	 * @param artificialInformation 杂工明细
	 * @return R
	 */
	@ApiOperation(value = "新增杂工明细", notes = "新增杂工明细")
	@SysLog("新增杂工明细")
	@PostMapping
	public R save(@RequestBody ArtificialInformation artificialInformation) {
		artificialInformationService.save(artificialInformation);
		backUtils.backArtificialInformationByIds(Arrays.asList(artificialInformation.getId()), "新增");
		Long dutyRecordId = artificialInformation.getDutyRecordId();
		ThreadUtil.execute(() -> dutyRecordService.refreshPendingById(dutyRecordId));
		return R.ok(artificialInformation.getId());
	}

	/**
	 * 修改杂工明细
	 *
	 * @param artificialInformation 杂工明细
	 * @return R
	 */
	@ApiOperation(value = "修改杂工明细", notes = "修改杂工明细")
	@SysLog("修改杂工明细")
	@PutMapping
	public R updateById(@RequestBody ArtificialInformation artificialInformation) {
		boolean result = artificialInformationService.updateById(artificialInformation);
		backUtils.backArtificialInformationByIds(Arrays.asList(artificialInformation.getId()), "修改");
		return R.ok(result);
	}

	/**
	 * 检验个人工时
	 *
	 * @param artificialInformation 杂工明细
	 * @return R
	 */
	@ApiOperation(value = "检验个人工时", notes = "检验个人工时")
	@SysLog("检验个人工时")
	@PostMapping("checkPersonDutyTimeById")
	public R checkPersonDutyTimeById(@RequestBody ArtificialInformation artificialInformation) {
		return R.ok(null, artificialInformationService.checkPersonDutyTimeById(artificialInformation));
	}

	/**
	 * 批量修改杂工明细
	 *
	 * @param artificialInformationList
	 * @return R
	 */
	@ApiOperation(value = "修改杂工明细", notes = "修改杂工明细")
	@SysLog("修改杂工明细")
	@PostMapping("update")
	public R update(@RequestBody List<ArtificialInformation> artificialInformationList) {
		artificialInformationService.updateBatchById(artificialInformationList);
		List<Long> ids = artificialInformationList.stream().map(ArtificialInformation::getId).collect(Collectors.toList());
		backUtils.backArtificialInformationByIds(ids, "修改");
		return R.ok();
	}

	/**
	 * 批量检验个人工时
	 *
	 * @param artificialInformationList 杂工明细
	 * @return R
	 */
	@ApiOperation(value = "批量检验个人工时", notes = "批量检验个人工时")
	@SysLog("批量检验个人工时")
	@PostMapping("checkPersonDutyTime")
	public R checkPersonDutyTime(@RequestBody List<ArtificialInformation> artificialInformationList) {
		return R.ok(null, artificialInformationService.checkPersonDutyTime(artificialInformationList));
	}

	/**
	 * 通过id删除杂工明细
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "通过id删除杂工明细", notes = "通过id删除杂工明细")
	@SysLog("通过id删除杂工明细")
	@DeleteMapping("/{id}")
	public R removeById(@PathVariable Long id) {
		ArtificialInformation artificialInformation = artificialInformationService.getById(id);
		backUtils.backDeleteArtificialInformationByIds(Arrays.asList(id));
		artificialInformationService.removeById(id);
		Long dutyRecordId = artificialInformation.getDutyRecordId();
		ThreadUtil.execute(() -> dutyRecordService.refreshPendingById(dutyRecordId));
		return R.ok();
	}

	/**
	 * 删除杂工明细
	 *
	 * @param artificialInformation 杂工明细
	 * @return R
	 */
	@ApiOperation(value = "删除杂工明细", notes = "删除杂工明细")
	@SysLog("删除杂工明细")
	@PostMapping("/delete")
	public R delete(@RequestBody ArtificialInformation artificialInformation) {
		List<ArtificialInformation> list = artificialInformationService.list((Wrappers.<ArtificialInformation>lambdaQuery()
				.eq(ArtificialInformation::getDutyRecordId, artificialInformation.getDutyRecordId())
				.eq(ArtificialInformation::getHandymanTypeId, artificialInformation.getHandymanTypeId())));
		List<Long> ids = list.stream().map(ArtificialInformation::getId).collect(Collectors.toList());
		backUtils.backDeleteArtificialInformationByIds(ids);
		artificialInformationService.removeByIds(ids);
		Long dutyRecordId = artificialInformation.getDutyRecordId();
		ThreadUtil.execute(() -> dutyRecordService.refreshPendingById(dutyRecordId));
		return R.ok();
	}

}