//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package nc.bs.bd.pfxx.plugin;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import nc.bs.dao.BaseDAO;
import nc.bs.dao.DAOException;
import nc.bs.framework.common.NCLocator;
import nc.bs.logging.Log;
import nc.bs.pfxx.ISwapContext;
import nc.bs.pfxx.plugin.AbstractPfxxPlugin;
import nc.bs.trade.business.HYPubBO;
import nc.bs.trade.business.HYSuperDMO;
import nc.bs.uapbd.util.MyHelper;
import nc.bs.uapbd.util.ThirdPartyPostRequestUtil;
import nc.itf.bd.material.assign.IMaterialAssignService;
import nc.itf.bd.material.plan.IMaterialPlanQueryService;
import nc.itf.bd.material.plan.IMaterialPlanService;
import nc.jdbc.framework.processor.MapProcessor;
import nc.pubitf.uapbd.IMaterialPubService;
import nc.util.mmf.framework.base.MMValueCheck;
import nc.vo.bd.defdoc.DefdocVO;
import nc.vo.bd.errorlog.ErrLogReturnValue;
import nc.vo.bd.material.MaterialVO;
import nc.vo.bd.material.plan.MaterialPlanVO;
import nc.vo.bd.material.stock.MaterialReplVO;
import nc.vo.bd.material.stock.MaterialStockVO;
import nc.vo.pfxx.auxiliary.AggxsysregisterVO;
import nc.vo.pfxx.util.PfxxPluginUtils;
import nc.vo.pub.BusinessException;

import java.util.*;
import java.util.stream.Stream;

public class MaterialPlanPfxxPlugin extends AbstractPfxxPlugin {
    IMaterialPlanQueryService materialplanqueryservice = null;
    IMaterialPlanService materialplanservice = null;
    IMaterialAssignService assignservice = null;

    private static final String LOG_INFO_NAME = "qyMesLog";
    private static final Log logger = Log.getInstance(LOG_INFO_NAME);
    private static final String reqUrl = "/IF_QyErpApi.ashx?action=addwlxx";
    private Map<String, String> configParams;

    public MaterialPlanPfxxPlugin() {
    }

    protected Object processBill(Object vo, ISwapContext swapContext, AggxsysregisterVO aggvo) throws BusinessException {
        MaterialPlanVO planvo = (MaterialPlanVO) vo;
        MaterialPlanVO[] pvos = this.getMaterialPlanQueryService().queryMaterialPlanVOs(new String[]{planvo.getPk_org()}, planvo.getPk_material());
        if (pvos != null && pvos.length != 0) {
            planvo = this.updateMaterialPlan(pvos, planvo);
        } else {
            planvo = this.insertMaterialPlan(planvo);
            PfxxPluginUtils.addDocIDVsPKContrast(swapContext.getBilltype(), swapContext.getDocID(), planvo.getPrimaryKey());
        }

        return planvo.getPrimaryKey();
    }

    private MaterialPlanVO insertMaterialPlan(MaterialPlanVO planvo) throws BusinessException {
        ErrLogReturnValue value = this.getService().assignByPks(new String[]{planvo.getPk_material()}, new String[]{planvo.getPk_org()}, true);
        MaterialPlanVO[] pvos = this.getMaterialPlanQueryService().queryMaterialPlanVOs(new String[]{planvo.getPk_org()}, planvo.getPk_material());
        if (pvos != null && pvos.length > 0) {
            planvo = this.updateMaterialPlan(pvos, planvo);
        }

        return planvo;
    }

    private MaterialPlanVO updateMaterialPlan(MaterialPlanVO[] pvos, MaterialPlanVO planvo) throws BusinessException {
        List<MaterialReplVO> list = new ArrayList();
        MaterialPlanVO vo = pvos[0];
        String[] attrs = planvo.getAttributeNames();

        for (String attr : attrs) {
            if (planvo.getAttributeValue(attr) != null && !"materialrepl".equals(attr)) {
                vo.setAttributeValue(attr, planvo.getAttributeValue(attr));
            }
        }

        if (vo.getMaterialrepl() != null && vo.getMaterialrepl().length > 0) {
            for (MaterialReplVO replvo : vo.getMaterialrepl()) {
                replvo.setStatus(3);
                list.add(replvo);
            }
        }

        if (planvo.getMaterialrepl() != null && planvo.getMaterialrepl().length > 0) {
            for (MaterialReplVO replvo : planvo.getMaterialrepl()) {
                replvo.setStatus(2);
                list.add(replvo);
            }
        }

        vo.setMaterialrepl((MaterialReplVO[]) list.toArray(new MaterialReplVO[0]));
        vo = this.getMaterialPlanService().updateMaterialPlanVO(vo);
        syncQMS(vo);
        return vo;
    }

    private IMaterialPlanQueryService getMaterialPlanQueryService() {
        if (this.materialplanqueryservice == null) {
            this.materialplanqueryservice = (IMaterialPlanQueryService) NCLocator.getInstance().lookup(IMaterialPlanQueryService.class);
        }

        return this.materialplanqueryservice;
    }

    private IMaterialPlanService getMaterialPlanService() {
        if (this.materialplanservice == null) {
            this.materialplanservice = (IMaterialPlanService) NCLocator.getInstance().lookup(IMaterialPlanService.class);
        }

        return this.materialplanservice;
    }

    private IMaterialAssignService getService() {
        if (this.assignservice == null) {
            this.assignservice = (IMaterialAssignService) NCLocator.getInstance().lookup(IMaterialAssignService.class);
        }

        return this.assignservice;
    }

    private void syncQMS(MaterialPlanVO planVO) throws BusinessException {
        // 修改物料计划信息的接口执行之后同步修改启源物料
        configParams = MyHelper.getConfigParams("jm-config", null);
        buildSyncData(planVO);
    }

    /**
     * 构建同步数据
     */
    private void buildSyncData(MaterialPlanVO planVO) throws BusinessException {
        String pkMaterial = planVO.getPk_material();
        String pkOrg = planVO.getPk_org();
        HYPubBO hyPub = new HYPubBO();
        MaterialVO vo = (MaterialVO) hyPub.queryByPrimaryKey(MaterialVO.class, pkMaterial);
        // 判断物料的业务单元是否是精密公司，不是则跳过
        Integer num = MyHelper.checkIfOrg(configParams, pkMaterial, "jmOrg");
        if (num <= 0) {
            return;
        }
        // 字段值翻译
        // String pk_marbasclass = vo.getPk_marbasclass();
        // String mrlTypeName = MyHelper.getStrValByCondition(MarBasClassVO.getDefaultTableName(), MarBasClassVO.NAME,
        //         "pk_marbasclass = '" + pk_marbasclass + "'");
        // 计量单位
        Map unitMap = getGoodsInfo(pkMaterial);
        // 启源物料编码
        Map<String, MaterialPlanVO> planMap = queryMaterialPlanInfoByPks(new String[]{pkMaterial}, pkOrg,
                new String[]{MaterialPlanVO.DEF2});
        // 计划信息自定义项2（原系统编码）BIP传启源物料档案的物料编码，BIP中物料编码传启源自定义字段“BIP物料编码”
        String qyCode = "";
        if (MMValueCheck.isNotEmpty(planMap) &&
                MMValueCheck.isNotEmpty(planMap.get(pkMaterial))) {
            qyCode = planMap.get(pkMaterial).getDef2();
        } else {
            qyCode = vo.getCode();
        }
        // 1=未启用;2=已启用;3=已停用;
        Integer enablestate = vo.getEnablestate();
        String statusCode = (3 == enablestate) ? "1" : "0";
        Map<String, Object> stockMap = MyHelper.getMapValByCondition(MaterialStockVO.getDefaultTableName(), "def3,def4,martype",
                MaterialStockVO.PK_MATERIAL + " = '" + pkMaterial + "' and pk_org = '" + pkOrg + "'");
        // 制造件传启源
        if (!"MR".equals(stockMap.get("martype"))) {
            return;
        }
        // 物料标志和产品分类字段在库存信息页签中，分配物料的时候没有默认值，需要在此处设置
        // 物料标志
        String wlbz = "产品";
        String wlbzId = stockMap.get("def3") + "";
        String defName = getDefName("zdy-jmzz001", wlbzId);
        if (MMValueCheck.isNotEmpty(defName)) {
            wlbz = defName;
        }
        // 产品分类
        String cpfl;
        String cpflId = stockMap.get("def4") + "";
        String defName1 = getDefName("zdy-jmzz002", cpflId);
        if (MMValueCheck.isEmpty(defName1)) {
            return;// 缺少产品分类则跳过同步启源
        }
        cpfl = defName1;
        // 组装数据
        JSONObject singleObj = new JSONObject();
        // 批次编号，用于唯一标识当前传输的物料数据批次，便于追溯和批量处理
        long cts = System.currentTimeMillis();
        singleObj.put("batchid", cts);
        JSONObject contentObj = new JSONObject();
        contentObj.put("meswlbh", qyCode); // 启源物料编码
        contentObj.put("bipwlbh", vo.getCode()); // BIP物料编码
        contentObj.put("wlmc", vo.getName()); // 物料名称
        String wlxhgg = MyHelper.skipNull(vo.getMaterialtype()) + MyHelper.skipNull(vo.getMaterialspec());
        contentObj.put("wlxhgg", wlxhgg); // 物料型号规格
        contentObj.put("wlfl", ""); // 物料分类
        contentObj.put("cpfl", cpfl); // 产品分类
        contentObj.put("wlbz", wlbz); // 物料标志
        contentObj.put("sjjldw", unitMap.get("unitname")); // 设计计量单位
        contentObj.put("cgjldw", unitMap.get("deputy_unitname")); // 采购计量单位
        contentObj.put("zhxs", unitMap.getOrDefault("convertRate", "1.00")); // 转换系数
        contentObj.put("flag_fq", statusCode); // 1/0 传递1代表物料废弃
        contentObj.put("bz", vo.getMemo()); // 备注信息
        JSONArray contentArr = new JSONArray();
        contentArr.add(contentObj);
        singleObj.put("Content", contentArr);
        pushData(singleObj);
    }

    /**
     * 推送同步数据
     */
    private void pushData(JSONObject param) throws BusinessException {
        // String jsonString = param.toJSONString();
        // 转json字符串的时候保留null值
        String jsonStr = JSON.toJSONString(param,
                SerializerFeature.WriteMapNullValue,
                SerializerFeature.WriteNullStringAsEmpty
        );
        logger.error("QMS-Material-param = " + jsonStr);
        // NCCForUAPLogger.debug("QMS-Material-param = " + jsonStr);
        String baseUrl = configParams.get("qmsBaseUrl");
        String requestUrl = baseUrl + reqUrl;
        logger.error("QMS-Material-url = " + requestUrl);
        String result = ThirdPartyPostRequestUtil.sendPostRequest(requestUrl, jsonStr);
        JSONObject resultObj = JSONObject.parseObject(result);
        logger.error("QMS-Material-res = " + result);

        if (!"true".equals(resultObj.getString("success"))) {
            logger.error("QMS-Material-error,result[" + resultObj.toJSONString() + "]");
            throw new BusinessException("QMS-Material-error:" + resultObj.getString("message"));
        }
    }

    private Map getGoodsInfo(String pkMaterial) throws BusinessException {
        String sql = " select a.pk_measdoc, c.name unitname, b.pk_measdoc deputyUnit, d.name deputy_unitname, nvl(b.measrate, '1/1') measrate " +
                "from bd_material a " +
                "left join bd_materialconvert b on a.pk_material = b.pk_material " +
                "left join bd_measdoc c on a.pk_measdoc = c.pk_measdoc " +
                "left join bd_measdoc d on b.pk_measdoc = d.pk_measdoc " +
                "where a.pk_material = '" + pkMaterial + "' ";
        Map map = (Map) new BaseDAO().executeQuery(sql, new MapProcessor());
        map.put("convertRate", MyHelper.transferSpecialField(map.get("measrate") + ""));
        return map;
    }

    private boolean checkIfOrg(String code, Map<String, String> configParams) throws BusinessException {
        String targetCode = configParams.get("jmOrg");
        if (targetCode == null || nc.vo.am.common.util.StringUtils.isEmpty(targetCode)) {
            throw new BusinessException("未配置组织参数");
        }
        String[] orgItem = targetCode.split(",");
        for (String orgCode : orgItem) {
            if (!orgCode.isEmpty() && orgCode.equals(code)) {
                return false;
            }
        }
        return true;
    }

    public Map<String, MaterialPlanVO> queryMaterialPlanInfoByPks(String[] pks, String pk_stockorg,
                                                                  String[] fields) throws BusinessException {
        Map<String, MaterialPlanVO> map = null;
        List<String> vids = Stream.of(pks).filter(Objects::nonNull).distinct().toList();
        if (vids.isEmpty()) {
            map = new HashMap<>();
        } else {
            map = NCLocator.getInstance().lookup(IMaterialPubService.class)
                    .queryMaterialPlanInfoByPks(vids.toArray(new String[0]), pk_stockorg, fields);
        }

        return map;
    }

    /**
     * 获取自定义项信息
     */
    private String getDefName(String code, String pk_defdoc) {
        String res = "";
        String strWhere = " pk_defdoclist in (select pk_defdoclist from bd_defdoclist where code='" + code + "' and dr=0 )  and dr = 0 and pk_defdoc = '" + pk_defdoc + "'";
        try {
            DefdocVO[] defdocVOs = (DefdocVO[]) new HYSuperDMO().queryByWhereClause(DefdocVO.class, strWhere);
            if (defdocVOs != null && defdocVOs.length > 0) {
                res = defdocVOs[0].getName().trim();
            }
        } catch (DAOException e) {
            logger.error("gyMes-SaleOrder-error,getDefName[" + e.getMessage() + "]");
        }
        return res;
    }
}