package com.chinaztt.mes.plan.controller;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.chinaztt.mes.basic.service.IfsLogService;
import com.chinaztt.mes.common.wrapper.QueryWrapperUtil;
import com.chinaztt.mes.plan.dto.ManufacturingOrderDTO;
import com.chinaztt.mes.plan.dto.MoStructureComponentDTO;
import com.chinaztt.mes.plan.dto.UploadRefreshIfsOrderNoResultDTO;
import com.chinaztt.mes.plan.entity.ManufacturingOrderOperationTemplate;
import com.chinaztt.mes.plan.excel.ManufacturingOderUploadData;
import com.chinaztt.mes.plan.excel.ManufacturingOrderUploadListener;
import com.chinaztt.mes.plan.service.ManufacturingOrderService;
import com.chinaztt.ztt.common.core.util.R;
import com.chinaztt.ztt.common.log.annotation.SysLog;
import com.chinaztt.ztt.common.security.annotation.Inner;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;


/**
 * 制造订单表
 *
 * @author cxf
 * @date 2020-09-24 14:26:01
 */
@RestController
@AllArgsConstructor
@RequestMapping("/plan/manufacturingOrder")
@Api(value = "manufacturingOrder", tags = "制造订单表管理")
@Slf4j
public class ManufacturingOrderController {

	private final ManufacturingOrderService manufacturingOrderService;

	private IfsLogService ifsLogService;

	/**
	 * 分页查询
	 *
	 * @param page                  分页对象
	 * @param manufacturingOrderDTO 制造订单表
	 * @return
	 */
	@ApiOperation(value = "分页查询", notes = "分页查询")
	@GetMapping("/page")
	@PreAuthorize("@pms.hasPermission('plan_manufacturingorder_view')")
	public R getManufacturingOrderPage(Page page, ManufacturingOrderDTO manufacturingOrderDTO) {
		List<Long> list = new ArrayList<>();
		if (CollectionUtil.isNotEmpty(manufacturingOrderDTO.getCustomerList())) {
			list = manufacturingOrderDTO.getCustomerList();
		}
		return R.ok(manufacturingOrderService.getManufacturingOrderPage(page, QueryWrapperUtil.gen(manufacturingOrderDTO), list));
	}

	/**
	 * 车间订单导出
	 *
	 * @return
	 */
	@ApiOperation(value = "车间订单导出", notes = "车间订单导出")
	@GetMapping("/export")
	public void export(HttpServletResponse response, ManufacturingOrderDTO manufacturingOrderDTO) throws IOException {
		List<Long> list = new ArrayList<>();
		if (CollectionUtil.isNotEmpty(manufacturingOrderDTO.getCustomerList())) {
			list = manufacturingOrderDTO.getCustomerList();
		}
		manufacturingOrderService.export(response, QueryWrapperUtil.gen(manufacturingOrderDTO),list);
	}

	/**
	 * 分页查询制造订单报表
	 *
	 * @param page                  分页查询制造订单报表
	 * @param manufacturingOrderDTO 分页查询制造订单报表
	 * @return
	 */
	@ApiOperation(value = "分页查询制造订单报表", notes = "分页查询制造订单报表")
	@GetMapping("/statementPage")
	public R getStatementPage(Page page, ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.getStatementPage(page, QueryWrapperUtil.gen(manufacturingOrderDTO)));
	}

	/**
	 * @param page
	 * @param manufacturingOrderDTO
	 * @return
	 */
	@ApiOperation(value = "分页查询未排产制造订单", notes = "分页查询未排产制造订单")
	@GetMapping("/apsPage")
	@PreAuthorize("@pms.hasPermission('plan_manufacturingorder_view')")
	public R getApsManufacturingOrderPage(Page page, ManufacturingOrderDTO manufacturingOrderDTO) {
		List<Long> list = new ArrayList<>();
		if (CollectionUtil.isNotEmpty(manufacturingOrderDTO.getCustomerList())) {
			list = manufacturingOrderDTO.getCustomerList();
		}
		manufacturingOrderDTO.setPlanned(false);
		return R.ok(manufacturingOrderService.getManufacturingOrderPage(page, QueryWrapperUtil.gen(manufacturingOrderDTO), list));
	}

	/**
	 * 通过id查询制造订单表
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "通过id查询", notes = "通过id查询")
	@GetMapping("/{id}")
	@PreAuthorize("@pms.hasPermission('plan_manufacturingorder_view')")
	public R getById(@PathVariable("id") Long id) {
		return R.ok(manufacturingOrderService.selectById(id));
	}

	/**
	 * 根据零件判断是否存在工艺路线/工艺结构
	 *
	 * @param partId partId
	 * @return R
	 */
	@ApiOperation(value = "根据零件判断是否存在工艺路线/工艺结构", notes = "根据零件判断是否存在工艺路线/工艺结构")
	@GetMapping("/checkPart/{partId}/{workshopTypeCode}")
	public R checkPart(@PathVariable("partId") Long partId, @PathVariable("workshopTypeCode") String workshopTypeCode) {
		return R.ok(manufacturingOrderService.checkPart(partId, workshopTypeCode));
	}

	/**
	 * 新增制造订单表
	 *
	 * @param manufacturingOrderDTO 制造订单表
	 * @return R
	 */
	@ApiOperation(value = "新增制造订单表", notes = "新增制造订单表")
	@SysLog("新增制造订单表")
	@PostMapping
	@PreAuthorize("@pms.hasPermission('plan_manufacturingorder_add')")
	public R save(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return manufacturingOrderService.fullSave(manufacturingOrderDTO);
	}

	/**
	 * 从主计划新增车间订单
	 *
	 * @param manufacturingOrderDTO 制造订单表
	 * @return R
	 */
	@ApiOperation(value = "从主计划新增车间订单", notes = "从主计划新增车间订单")
	@SysLog("从主计划新增车间订单")
	@PostMapping("/saveFromSchdule")
	public R saveFromSchdule(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return manufacturingOrderService.fullSave(manufacturingOrderDTO);
	}

	/**
	 * 修改制造订单表
	 *
	 * @param manufacturingOrderDTO 制造订单表
	 * @return R
	 */
	@ApiOperation(value = "修改制造订单表", notes = "修改制造订单表")
	@SysLog("修改制造订单表")
	@PutMapping
	@PreAuthorize("@pms.hasPermission('plan_manufacturingorder_edit')")
	public R updateById(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return manufacturingOrderService.updateDtoById(manufacturingOrderDTO);
	}

	/**
	 * 通过id删除制造订单表
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "通过id删除制造订单表", notes = "通过id删除制造订单表")
	@SysLog("通过id删除制造订单表")
	@DeleteMapping("/{id}")
	@PreAuthorize("@pms.hasPermission('plan_manufacturingorder_del')")
	public R removeById(@PathVariable Long id) {
		return R.ok(manufacturingOrderService.removeById(id));
	}

	/**
	 * 状态变更
	 *
	 * @param ids
	 * @return R
	 */
	@ApiOperation(value = "状态变更", notes = "状态变更")
	@SysLog("状态变更")
	@PostMapping("/changeState/{event}")
	public R changeMarkPlanned(@RequestBody List<Long> ids, @PathVariable String event) {
		return R.ok(manufacturingOrderService.changeState(ids, event));
	}

	/**
	 * 根据制造订单id和工艺id校验该制造订单对应的工艺是否一致
	 *
	 * @param manufacturingOrderDTO 制造订单表
	 * @return
	 */
	@ApiOperation(value = "根据制造订单id和工艺id校验该制造订单对应的工艺是否一致", notes = "根据制造订单id和工艺id校验该制造订单对应的工艺是否一致")
	@GetMapping("/checkout")
	public R checkoutManufacturingOrder(ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.checkoutManufacturingOrder(manufacturingOrderDTO));
	}

	/**
	 * 根据工艺id和工序id获取复制的工序模板
	 *
	 * @param manufacturingOrderDTO 制造订单表
	 * @return
	 */
	@ApiOperation(value = "根据工艺id和工序id获取复制的工序模板", notes = "根据工艺id和工序id获取复制的工序模板")
	@GetMapping("/planRoutingOperationTemplate")
	public R getOperationTemplate(ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.getOperationTemplate(manufacturingOrderDTO));
	}

	/**
	 * 根据复制工序模板的id删除工序模板
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "根据复制工序模板的id删除工序模板", notes = "根据复制工序模板的id删除工序模板")
	@SysLog("根据复制工序模板的id删除工序模板")
	@DeleteMapping("/deleteRoutingTemplate/{id}")
	public R deleteRoutingTemplate(@PathVariable Long id) {
		return R.ok(manufacturingOrderService.deleteRoutingTemplate(id));
	}

	/**
	 * 修改制造订单模板
	 *
	 * @param manufacturingOrderOperationTemplate 修改制造订单模板
	 * @return R
	 */
	@ApiOperation(value = "修改制造订单模板", notes = "修改制造订单模板")
	@SysLog("修改制造订单模板")
	@PutMapping("updateTemplate")
	public R updateTemplate(@RequestBody ManufacturingOrderOperationTemplate manufacturingOrderOperationTemplate) {
		return R.ok(manufacturingOrderService.updateTemplate(manufacturingOrderOperationTemplate));
	}

	/**
	 * 根据工艺工序id关联添加工序模板
	 *
	 * @param manufacturingOrderDTO
	 * @return
	 */
	@ApiOperation(value = "根据工艺工序id关联添加工序模板", notes = "根据工艺工序id关联添加工序模板")
	@PostMapping("/addRoutingTemplate")
	public R addOperationTemplate(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.addOperationTemplate(manufacturingOrderDTO));
	}

	/**
	 * 根据工艺工序id和工序模板id获取工序参数
	 *
	 * @param manufacturingOrderDTO 制造订单表
	 * @return
	 */
	@ApiOperation(value = "根据工艺工序id和工序模板id获取工序参数", notes = "根据工艺工序id和工序模板id获取工序参数")
	@GetMapping("/planRoutingOperationTemplateParam")
	public R getOperationTemplateParam(ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.getOperationTemplateParam(manufacturingOrderDTO));
	}

	/**
	 * 根据复制工序参数的id删除工序参数
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "根据复制工序参数的id删除工序参数", notes = "根据复制工序参数的id删除工序参数")
	@SysLog("根据复制工序参数的id删除工序参数")
	@DeleteMapping("/deleteRoutingTemplateParam/{id}")
	public R deleteRoutingTemplateParam(@PathVariable Long id) {
		return R.ok(manufacturingOrderService.deleteRoutingTemplateParam(id));
	}

	/**
	 * 根据工艺工序id和工序模板id关联添加工序参数
	 *
	 * @param manufacturingOrderDTO
	 * @return
	 */
	@ApiOperation(value = "根据工艺工序id和工序模板id关联添加工序参数", notes = "根据工艺工序id和工序模板id关联添加工序参数")
	@PostMapping("/addRoutingTemplateParam")
	public R addOperationTemplateParam(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.addOperationTemplateParam(manufacturingOrderDTO));
	}

	/**
	 * 工序参数的参数值的修改
	 *
	 * @param manufacturingOrderDTO 工艺
	 * @return R
	 */
	@ApiOperation(value = "工序参数的参数值的修改", notes = "工序参数的参数值的修改")
	@SysLog("工序参数的参数值的修改")
	@PutMapping("routingTemplateParam")
	public R updateRoutingTemplateParamById(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.updateRoutingTemplateParamById(manufacturingOrderDTO));
	}

	/**
	 * bom切换，查询相关信息
	 *
	 * @param bomId
	 * @return
	 */
	@GetMapping("/bomSelectChange/{bomId}")
	public R bomSelectChange(@PathVariable Long bomId) {
		return R.ok(manufacturingOrderService.bomSelectChange(bomId));
	}

	/**
	 * 通过制造订单id查询客户订单
	 *
	 * @param id id
	 * @return R
	 */
	@ApiOperation(value = "通过制造订单id查询客户订单", notes = "通过制造订单id查询客户订单")
	@GetMapping("/getCustomer/{id}")
	public R getCustomer(@PathVariable("id") Long id) {
		return R.ok(manufacturingOrderService.getCustomer(id));
	}

	/**
	 * 通过制造订单id和零件id找到产出所需数量
	 *
	 * @param id     制造订单id
	 * @param partId 零件id
	 * @return
	 */
	@ApiOperation(value = "通过制造订单id和零件id找到产出所需数量")
	@GetMapping("/getQpaNumber")
	public R getQpaNumber(@Valid @NotNull Long id, @Valid @NotNull Long partId) {
		return R.ok(manufacturingOrderService.getQpaNumber(id, partId));
	}

	/**
	 * ifs查询车间订单申请
	 *
	 * @param manufacturingOrderDTO partNo           零件编号
	 *                              partName         零件描述
	 *                              workshopTypeCode 车间订单类型
	 *                              state            状态
	 *                              createUser       计划人
	 * @return
	 */
	@ApiOperation(value = "ifs查询车间订单申请")
	@GetMapping("/queryShopOrderReqStd")
	public R queryShopOrderReqStd(ManufacturingOrderDTO manufacturingOrderDTO) {
		return manufacturingOrderService.queryShopOrderReqStd(manufacturingOrderDTO);
	}

	/**
	 * ifs车间订单更新/新增接口
	 *
	 * @param ids
	 * @return
	 */
	@ApiOperation(value = "ifs车间订单更新/新增接口")
	@PostMapping("/importShopOrderStd")
	public R importShopOrderStd(@RequestBody List<Long> ids) {
		return manufacturingOrderService.importShopOrderStd(ids);
	}


	/**
	 * ifs车间订单物料更新
	 *
	 * @param ids
	 * @return
	 */
	@ApiOperation(value = "ifs车间订单物料更新")
	@PostMapping("/modifyShopMaterialAllocStd")
	public R modifyShopMaterialAllocStd(@RequestBody List<Long> ids) {
		return manufacturingOrderService.modifyShopMaterialAllocStd(ids);
	}

	/**
	 * ifs车间订单工序更新
	 *
	 * @param ids
	 * @return
	 */
	@ApiOperation(value = "ifs车间订单工序更新")
	@PostMapping("/modifyShopOperationStd")
	public R modifyShopOperationStd(@RequestBody List<Long> ids) {
		return manufacturingOrderService.modifyShopOperationStd(ids);
	}


	/**
	 * 批量创建车间订单
	 *
	 * @param manufacturingOrderDTOS
	 * @return
	 */
	@ApiOperation(value = "批量创建车间订单")
	@PostMapping("/addBatch")
	public R addBatch(@RequestBody List<ManufacturingOrderDTO> manufacturingOrderDTOS) {
		return manufacturingOrderService.addBatch(manufacturingOrderDTOS);
	}


	/**
	 * 车间订单BOM修改
	 *
	 * @param moStructureComponentDTO
	 * @return
	 */
	@ApiOperation(value = "车间订单BOM修改")
	@PutMapping("/updateMoBom")
	public R updateMoBom(@RequestBody MoStructureComponentDTO moStructureComponentDTO) {
		return R.ok(manufacturingOrderService.updateMoBom(moStructureComponentDTO));
	}

	/**
	 * 删除车间订单bom节点
	 *
	 * @param id
	 * @return
	 */
	@ApiOperation(value = "删除车间订单")
	@DeleteMapping("/delMoBom/{id}")
	public R delMoBom(@PathVariable("id") Long id) {
		return R.ok(manufacturingOrderService.delMoBom(id));
	}

	/**
	 * 新增车间订单bom节点
	 *
	 * @param moStructureComponent bom节点
	 * @return
	 */
	@ApiOperation(value = "新增车间订单bom节点")
	@PostMapping("/addMoBomCompont")
	public R addMoBomCompont(@RequestBody MoStructureComponentDTO moStructureComponent) {
		return R.ok(manufacturingOrderService.addMoBomCompont(moStructureComponent));
	}

	/**
	 * 判断车间订单是否可以合并
	 *
	 * @param ids bom节点
	 * @return
	 */
	@ApiOperation(value = "判断车间订单是否可以合并")
	@PostMapping("/mergeCheck")
	public R mergeCheck(@RequestBody List<Long> ids) {
		return R.ok(manufacturingOrderService.mergeCheck(ids));
	}

	/**
	 * 后台拼接合并车间订单
	 *
	 * @param id  目标订单id
	 * @param ids 被合并订单id
	 * @return
	 */
	@ApiOperation(value = "订单合并数据")
	@PostMapping("/mergeOrder/{id}")
	public R mergeOrder(@PathVariable("id") Long id, @RequestBody List<Long> ids) {
		return R.ok(manufacturingOrderService.mergeOrder(id, ids));
	}

	/**
	 * 合并后的车间订单
	 *
	 * @return
	 */
	@PostMapping("/mergeUpdate")
	public R mergeUpdate(@RequestBody ManufacturingOrderDTO manufacturingOrderDTO) {
		return R.ok(manufacturingOrderService.mergeUpdate(manufacturingOrderDTO));
	}

	/**
	 * 月结拆单后，更新车间订单和ifs缓存中的ifs订单号
	 * @return
	 */
	@PostMapping("/refreshIfsOrderNo")
	public R refreshIfsOrderNo() {
		try {
			manufacturingOrderService.refreshIfsOrderNo();
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		manufacturingOrderService.refreshIfsLogOrderNo();
		return R.ok();
	}

	@Inner(value = false)
	@PostMapping("/uploadRefreshIfsOrderNo")
	@ApiOperation(value = "上传文件更新月结ifs订单号")
	public R uploadRefreshIfsOrderNo(@RequestParam("file") MultipartFile file) {
		try {
			List<UploadRefreshIfsOrderNoResultDTO> resultDTOList = new ArrayList<>();
			EasyExcel.read(file.getInputStream(), ManufacturingOderUploadData.class,
					new ManufacturingOrderUploadListener(manufacturingOrderService, resultDTOList)).sheet().doRead();
			manufacturingOrderService.refreshIfsLogOrderNo();
			return R.ok(resultDTOList);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			return R.failed(e.getMessage());
		}
	}
}