package com.jeesite.modules.mes.web;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import com.jeesite.common.lang.StringUtils;
import com.jeesite.common.service.ServiceException;
import com.jeesite.modules.mes.resp.CommonResp;
import com.jeesite.modules.mes.service.MesLaserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.jeesite.common.config.Global;
import com.jeesite.common.web.BaseController;

/**
 * 镭雕对接Controller（OP040）
 * MES客户端拿到镭雕软件回传的钢印码后，调用本接口生成并绑定21位客户编码。
 * @author hzd
 * @version 2026-07-08
 */
@Controller
@RequestMapping(value = "${adminPath}/mes/mesLaser")
public class MesLaserController extends BaseController {

	@Autowired
	private MesLaserService mesLaserService;

	/**
	 * 生成客户编码并与钢印码绑定
	 * 请求参数（form）：prodCode(T09/T68) steelSn(钢印码) oprno lineSn user
	 * 返回 data：客户编码（21位）
	 */
	@PostMapping(value = "genCustomerSn")
	@ResponseBody
	public CommonResp genCustomerSn(HttpServletRequest request) {
		CommonResp<String> resp = new CommonResp<>();
		String prodCode = request.getParameter("prodCode");
		String steelSn = request.getParameter("steelSn");
		String oprno = request.getParameter("oprno");
		String lineSn = request.getParameter("lineSn");
		String user = request.getParameter("user");

		if (StringUtils.isEmpty(prodCode) || StringUtils.isEmpty(steelSn)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("参数错误：prodCode和steelSn不能为空");
			return resp;
		}

		try {
			String customerSn = mesLaserService.genAndBindCustomerSn(prodCode, steelSn, oprno, lineSn, user);
			resp.setData(customerSn);
			resp.setResult(Global.TRUE);
			resp.setMessage("生成成功");
		} catch (ServiceException e) {
			resp.setResult(Global.FALSE);
			resp.setMessage(e.getMessage());
		} catch (Exception e) {
			logger.error("生成客户编码失败：prodCode=" + prodCode + ", steelSn=" + steelSn, e);
			resp.setResult(Global.FALSE);
			resp.setMessage("生成失败：" + e.getMessage());
		}

		return resp;
	}

	/**
	 * 解绑钢印码和客户码映射。客户码建档数据保留。
	 * 请求参数（form）：steelSn(钢印码) oprno lineSn
	 * 返回 data：被解绑的客户码
	 */
	@PostMapping(value = "unbindSteelSn")
	@ResponseBody
	public CommonResp unbindSteelSn(HttpServletRequest request) {
		CommonResp<String> resp = new CommonResp<>();
		String steelSn = request.getParameter("steelSn");
		String oprno = request.getParameter("oprno");
		String lineSn = request.getParameter("lineSn");

		if (StringUtils.isEmpty(steelSn)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("参数错误：steelSn不能为空");
			return resp;
		}

		try {
			String customerSn = mesLaserService.unbindSteelSn(steelSn, oprno, lineSn);
			resp.setData(customerSn);
			resp.setResult(Global.TRUE);
			resp.setMessage("解绑成功，客户码：" + customerSn);
		} catch (ServiceException e) {
			resp.setResult(Global.FALSE);
			resp.setMessage(e.getMessage());
		} catch (Exception e) {
			logger.error("钢印码解绑失败：steelSn=" + steelSn, e);
			resp.setResult(Global.FALSE);
			resp.setMessage("解绑失败：" + e.getMessage());
		}

		return resp;
	}

	// ==== 新流程：PDA 提交 + OP40 客户端轮询打印 ====

	/**
	 * PDA 端提交钢印码：服务端生成客户码，绑定并入待打印队列。
	 * 请求参数（form）：steelSn / prodCode
	 * 返回 data.customerSn（21位客户码）
	 * 说明：lineSn 和 user 由服务端固定填入（lineSn=T9，user=pda），PDA 端不用传。
	 */
	@PostMapping(value = "submitSteelSn")
	@ResponseBody
	public CommonResp<Map<String, String>> submitSteelSn(HttpServletRequest request) {
		CommonResp<Map<String, String>> resp = new CommonResp<>();
		String steelSn = request.getParameter("steelSn");
		String prodCode = request.getParameter("prodCode");

		if (StringUtils.isEmpty(steelSn)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("steelSn 不能为空");
			return resp;
		}
		if (StringUtils.isEmpty(prodCode)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("prodCode 不能为空");
			return resp;
		}
		try {
			String customerSn = mesLaserService.submitSteelSn(prodCode, steelSn);
			Map<String, String> data = new HashMap<>();
			data.put("customerSn", customerSn);
			resp.setData(data);
			resp.setResult(Global.TRUE);
			resp.setMessage("提交成功");
		} catch (ServiceException e) {
			resp.setResult(Global.FALSE);
			resp.setMessage(e.getMessage());
		} catch (Exception e) {
			logger.error("PDA 提交钢印码失败：steelSn=" + steelSn, e);
			resp.setResult(Global.FALSE);
			resp.setMessage("提交失败：" + e.getMessage());
		}
		return resp;
	}

	/**
	 * PDA 扫码打流转卡：把 steelSn 对应记录标记为拉铆待打印。
	 * 请求参数（form）：steelSn —— 内容可以是钢印码，也可以是软客户码（以 + 开头视为客户码）。
	 * PDA 端不用改，后端根据内容自动路由到 steel_sn 或 customer_sn 查询。
	 * 返回 data.rows = UPDATE 影响行数，0 表示未找到或状态不允许重复标记
	 */
	@PostMapping(value = "markRvtPrint")
	@ResponseBody
	public CommonResp<Map<String, Object>> markRvtPrint(HttpServletRequest request) {
		CommonResp<Map<String, Object>> resp = new CommonResp<>();
		String steelSn = request.getParameter("steelSn");
		if (StringUtils.isEmpty(steelSn)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("steelSn 不能为空");
			return resp;
		}

		// 自动判定：以 + 开头视为软客户码，否则按钢印码
		boolean byCustomer = steelSn.startsWith("+");
		String snType = byCustomer ? "客户码" : "钢印码";

		try {
			int rows = byCustomer
					? mesLaserService.markRvtPrintByCustomerSn(steelSn)
					: mesLaserService.markRvtPrint(steelSn);
			Map<String, Object> data = new HashMap<>();
			data.put("rows", rows);
			resp.setData(data);
			if (rows > 0) {
				resp.setResult(Global.TRUE);
				resp.setMessage("已标记为拉铆待打印");
			} else {
				resp.setResult(Global.FALSE);
				resp.setMessage("未找到该" + snType + "或状态不允许重复标记：" + steelSn);
			}
		} catch (Exception e) {
			logger.error("markRvtPrint 失败：" + snType + "=" + steelSn, e);
			resp.setResult(Global.FALSE);
			resp.setMessage("标记失败：" + e.getMessage());
		}
		return resp;
	}

	/**
	 * 拉铆打印代理客户端拉取待打印列表（FIFO，按创建时间升序）。
	 * @param limit 单次条数上限，默认 10
	 * @return data 列表元素含 customerSn / steelSn / prodCode / oprno / createDate
	 */
	@RequestMapping(value = "pendingPrint")
	@ResponseBody
	public CommonResp<List<Map<String, Object>>> pendingPrint(
			@RequestParam(value = "limit", required = false, defaultValue = "10") int limit) {
		CommonResp<List<Map<String, Object>>> resp = new CommonResp<>();
		try {
			List<Map<String, Object>> list = mesLaserService.listPending(limit);
			resp.setData(list);
			resp.setResult(Global.TRUE);
			resp.setMessage("OK");
		} catch (Exception e) {
			logger.error("拉取待打印列表失败", e);
			resp.setResult(Global.FALSE);
			resp.setMessage("拉取失败：" + e.getMessage());
		}
		return resp;
	}

	/**
	 * 拉铆打印代理上报打印结果。
	 * 请求参数（form）：customerSn / result=OK|NG / msg（失败原因，可选）
	 * OK → rivet_print_status 1→2；NG → rivet_print_status 1→3。
	 */
	@PostMapping(value = "printAck")
	@ResponseBody
	public CommonResp printAck(HttpServletRequest request) {
		CommonResp<String> resp = new CommonResp<>();
		String customerSn = request.getParameter("customerSn");
		String result = request.getParameter("result");
		String msg = request.getParameter("msg");

		if (StringUtils.isEmpty(customerSn)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("customerSn 不能为空");
			return resp;
		}
		if (!"OK".equalsIgnoreCase(result) && !"NG".equalsIgnoreCase(result)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("result 只能是 OK/NG");
			return resp;
		}
		try {
			int rows = mesLaserService.ackPrint(customerSn, result, msg);
			resp.setResult(Global.TRUE);
			resp.setMessage("ack 已接收，影响行数 " + rows);
		} catch (Exception e) {
			logger.error("打印结果 ack 失败：customerSn=" + customerSn, e);
			resp.setResult(Global.FALSE);
			resp.setMessage("ack 失败：" + e.getMessage());
		}
		return resp;
	}

	/**
	 * 根据客户码查询钢印码（用于打印流转卡）
	 * 请求参数（form）：customerSn
	 * 返回 data 为钢印码字符串
	 */
	@PostMapping(value = "getSteelSn")
	@ResponseBody
	public CommonResp<Map<String, String>> getSteelSn(HttpServletRequest request) {
		CommonResp<Map<String, String>> resp = new CommonResp<>();
		String customerSn = request.getParameter("customerSn");

		if (StringUtils.isEmpty(customerSn)) {
			resp.setResult(Global.FALSE);
			resp.setMessage("customerSn 不能为空");
			return resp;
		}

		try {
			String steelSn = mesLaserService.getSteelSnByCustomerSn(customerSn);
			if (steelSn != null) {
				Map<String, String> data = new HashMap<>();
				data.put("steelSn", steelSn);
				resp.setData(data);
				resp.setResult(Global.TRUE);
				resp.setMessage("查询成功");
			} else {
				resp.setResult(Global.FALSE);
				resp.setMessage("未找到该客户码对应的钢印码");
			}
		} catch (Exception e) {
			logger.error("查询钢印码失败：customerSn=" + customerSn, e);
			resp.setResult(Global.FALSE);
			resp.setMessage("查询失败：" + e.getMessage());
		}
		return resp;
	}
}