package com.huaheng.pc.srm.service;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.api.srm.domain.*;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.RunFailException;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.Wrappers;
import com.huaheng.common.utils.http.OkHttpUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.address.domain.Address;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.company.domain.CompanyU8;
import com.huaheng.pc.config.company.service.CompanyU8Service;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.supplier.service.SupplierService;
import com.huaheng.pc.monitor.apilog.domain.ApiLog;
import com.huaheng.pc.srm.domain.*;
import com.huaheng.pc.srm.mapper.ICSASNMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class ICSASNService extends ServiceImpl<ICSASNMapper, ICSASN> {

    private static final Logger logger = LoggerFactory.getLogger(ICSASNService.class);

    @Resource
    private ICSASNService icsasnService;
    @Resource
    private ICSASNDetailService icsasnDetailService;
    @Resource
    RunFailException runFailException;
    @Resource
    SupplierService supplierService;
    @Resource
    private MaterialService materialService;
    @Resource
    private SrmHeaderService srmHeaderService;
    @Resource
    private SrmDetailService srmDetailService;
    @Resource
    private ICSITEMLotService icsitemLotService;
    @Resource
    private AddressService addressService;
    @Resource
    private CompanyU8Service companyU8Service;


    public List<ICSASN> selectListEntity(ICSASN icsasn) {
        LambdaQueryWrapper<ICSASN> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(StringUtils.isNotEmpty(icsasn.getSTNO()), ICSASN::getSTNO, icsasn.getSTNO());
        queryWrapper.eq(StringUtils.isNotEmpty(icsasn.getWarehouseCode()), ICSASN::getWarehouseCode, icsasn.getWarehouseCode());
        return this.list(queryWrapper);
    }

    public List<ICSASN> selectBySTNO(List<String> STNOS) {
        if (STNOS != null && STNOS.size() > 0) {
            String[] split = STNOS.toArray(new String[0]);
            LambdaQueryWrapper<ICSASN> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.in(ICSASN::getSTNO, split);
            return this.list(queryWrapper);
        }
        return null;
    }


    public boolean update(ICSASN icsasn) {
        return this.update(icsasn);
    }

    /**
     * 接收送货单信息
     *
     * @param icsOrder
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public SRMResult saveASNAndDetail(ICSOrder icsOrder) {
        SRMResult srmResult = new SRMResult();
        ICSASN icsasn = icsOrder.getIcsasn();
        //1、判断货主(账套号)
        if (StringUtils.isEmpty((icsasn.getCompanyCode()))) {
            return srmResult.error("账套号为空");
        }
        if (StringUtils.isEmpty((icsasn.getWarehouseCode()))) {
            return srmResult.error("仓库code为空");
        }
        CompanyU8 companyWu = companyU8Service.getOne(new LambdaQueryWrapper<CompanyU8>()
                .eq(CompanyU8::getWarehouseCode, icsasn.getWarehouseCode())
                .like(CompanyU8::getUCompanyCode, icsasn.getCompanyCode())
                .last("order by id asc limit 1")
        );
        if (companyWu == null) {
            return srmResult.error(icsasn.getCompanyCode() + "账套号不存在");
        }
        //2、判断供应商是否存在
        String supplierName = supplierService.getSuppierNameByCode(icsasn.getVENDORCODE(), icsasn.getWarehouseCode());
        if (supplierName == null) {
            runFailException.sendException("头表ID为：" + icsasn.getID() + "的送货单供应商在wms不存在");
            return srmResult.error("头表ID为：" + icsasn.getID() + "的送货单供应商在wms不存在");
        }
        //3、操作头表icsasn和srmHeader
        Integer headerId = null;
        ICSASN queryHeaderEntry = new ICSASN();
        queryHeaderEntry.setSTNO(icsasn.getSTNO());
        queryHeaderEntry.setWarehouseCode(icsasn.getWarehouseCode());
        if (this.selectListEntity(queryHeaderEntry).size() > 0) {
            //①判断送货单头表是否存在，已存在，则更新
            if (!this.updateById(icsasn)) {
                runFailException.sendException("更新送货单头表失败，头表ID为：" + icsasn.getID());
                return srmResult.error("更新送货单头表失败，头表ID为：" + icsasn.getID());
            }
            SrmHeader srmHeader = new SrmHeader();
            srmHeader.setCode(icsasn.getSTNO());
            srmHeader.setWarehouseCode(icsasn.getWarehouseCode());
            srmHeader = srmHeaderService.selectFirstModel(srmHeader);
            SrmHeader model = this.getSrmHeader(icsasn);
            model.setId(srmHeader.getId());
            srmHeaderService.updateById(model);
            headerId = srmHeader.getId();
        } else {
            //②判断送货单头表是否存在，不存在，则插入
            if (!this.save(icsasn)) {
                runFailException.sendException("插入送货单头表失败，头表ID为：" + icsasn.getID());
                return srmResult.error("插入送货单头表失败，头表ID为：" + icsasn.getID());
            }
            SrmHeader model = this.getSrmHeader(icsasn);
            srmHeaderService.save(model);
            SrmHeader srmHeader = new SrmHeader();
            srmHeader.setCode(model.getCode());
            srmHeader = srmHeaderService.selectFirstModel(srmHeader);
            headerId = srmHeader.getId();
        }
        //3、操作明细表icsasndetail和srmDetail
        if (icsOrder.getIcsasnDetailList().size() > 0) {
            //①icsasnDetail添加物料信息
            for (ICSASNDetail icsasnDetail : icsOrder.getIcsasnDetailList()) {
                //查询SRM有没有推送物料条码
                ICSITEMLot queryIcsitemLot = new ICSITEMLot();
                queryIcsitemLot.setLotNO(icsasnDetail.getLOTNO());
                queryIcsitemLot.setWarehouseCode(icsasn.getWarehouseCode());
                ICSITEMLot icsitemLot = icsitemLotService.selectFirstModel(queryIcsitemLot);
                if (icsitemLot == null) {
                    runFailException.sendException("ID为：" + icsasnDetail.getID() + "的物料条码没有同步到wms");
                    return srmResult.error("ID为：" + icsasnDetail.getID() + "的物料条码没有同步到wms");
                }
                Material material = materialService.getMaterialByCode(icsitemLot.getItemCode(), icsasn.getWarehouseCode());
                if (material == null) {
                    runFailException.sendException("ID为：" + icsasnDetail.getID() + "的物料条码在wms不存在");
                    return srmResult.error("ID为：" + icsasnDetail.getID() + "的物料条码在wms不存在");
                }
                icsasnDetail.setMaterialCode(material.getCode());
                icsasnDetail.setMaterialName(material.getName());
                icsasnDetail.setSpec(material.getSpec());
                icsasnDetail.setWarehouseCode(material.getWarehouseCode());
            }
            //②查询送货单号STNO是否存在明细
            ICSASNDetail queryDetailEntry = new ICSASNDetail();
            queryDetailEntry.setSTNO(icsasn.getSTNO());
            queryDetailEntry.setWarehouseCode(icsasn.getWarehouseCode());
            List<ICSASNDetail> icsasnDetailList = icsasnDetailService.selectListEntity(queryDetailEntry);
            if (icsasnDetailList.size() > 0) {
                //③送货单号STNO已存在的明细进行更新
                for (ICSASNDetail icsasnDetail : icsOrder.getIcsasnDetailList()) {
                    queryDetailEntry.setID(icsasnDetail.getID());
                    queryDetailEntry.setWarehouseCode(icsasnDetail.getWarehouseCode());
                    if (icsasnDetailService.selectListEntity(queryDetailEntry).size() > 0) {
                        if (!icsasnDetailService.updateById(icsasnDetail)) {
                            runFailException.sendException("更新送货单明细失败，头表ID为：" + icsasnDetail.getID());
                            return srmResult.error("更新送货单明细失败，头表ID为：" + icsasnDetail.getID());
                        }
                        SrmDetail srmDetail = new SrmDetail();
                        srmDetail.setMark(icsasnDetail.getID());
                        srmDetail.setWarehouseCode(icsasnDetail.getWarehouseCode());
                        srmDetail = srmDetailService.selectFirstModel(srmDetail);
                        SrmDetail model = this.getSrmDetail(icsasnDetail, srmDetail.getHeaderId(), companyWu);
                        model.setId(srmDetail.getId());
                        srmDetailService.updateById(model);
                    } else {
                        if (!icsasnDetailService.save(icsasnDetail)) {
                            runFailException.sendException("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                            return srmResult.error("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                        }
                        SrmDetail srmDetail = this.getSrmDetail(icsasnDetail, headerId, companyWu);
                        srmDetailService.save(srmDetail);
                    }
                }
            } else {
                //④送货单号STNO不存在的明细进行新增
                for (ICSASNDetail icsasnDetail : icsOrder.getIcsasnDetailList()) {
                    if (icsasnDetail.getSTNO().equals(icsasn.getSTNO())) {
                        if (!icsasnDetailService.save(icsasnDetail)) {
                            runFailException.sendException("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                            return srmResult.error("插入送货单明细失败，头表ID为：" + icsasnDetail.getID());
                        }
                        SrmDetail srmDetail = this.getSrmDetail(icsasnDetail, headerId, companyWu);
                        srmDetailService.save(srmDetail);
                    }
                }
            }
        }

        return srmResult.success("送货单列表推送成功");
    }


    public SrmHeader getSrmHeader(ICSASN icsasn) {
        SrmHeader srmHeader = new SrmHeader();
        srmHeader.setCode(icsasn.getSTNO());
        srmHeader.setMark(icsasn.getID());
        srmHeader.setSupplierCode(icsasn.getVENDORCODE());
        srmHeader.setOperator(icsasn.getMUSERName());
        srmHeader.setOperatorTime(icsasn.getMTIME());
        srmHeader.setCreated(new Date());
        srmHeader.setWarehouseCode(icsasn.getWarehouseCode());
        return srmHeader;

    }

    public SrmDetail getSrmDetail(ICSASNDetail icsasnDetail, Integer headerId, CompanyU8 companyWu) {
        SrmDetail srmDetail = new SrmDetail();
        srmDetail.setHeaderId(headerId);
        srmDetail.setCode(icsasnDetail.getSTNO());
        srmDetail.setCompanyCode(companyWu.getUCompanyCode());
        srmDetail.setMark(icsasnDetail.getID());
        srmDetail.setLineCode(icsasnDetail.getLOTNO());
        srmDetail.setMaterialCode(icsasnDetail.getMaterialCode());
        srmDetail.setMaterialName(icsasnDetail.getMaterialName());
        srmDetail.setSpecification(icsasnDetail.getSpec());
        srmDetail.setQty(icsasnDetail.getPLANQTY());
        srmDetail.setConfirmQty(icsasnDetail.getRECEIVEQTY());
        srmDetail.setOperator(icsasnDetail.getMUSERName());
        srmDetail.setOperatorTime(icsasnDetail.getMTIME());
        srmDetail.setCreated(new Date());
        srmDetail.setWarehouseCode(icsasnDetail.getWarehouseCode());
        srmDetail.setProductionBatch(icsasnDetail.getCdefine22());
        srmDetail.setBatchNumberContent(icsasnDetail.getCdefine23());
        return srmDetail;
    }


    public Address getSRMAddress(String warehouseCode) {
        Address address = new Address();
        address.setParam("SRM");
        address.setWarehouseCode(warehouseCode);
        address = addressService.selectEntity(address);
        return address;
    }


    @Transactional
    public SRMResult sendReturn(String url, String json, String warehouseCode) {
        if (StringUtils.isEmpty(warehouseCode)) {
            warehouseCode = "CS0001";
        }
        SRMResult ajaxResult = new SRMResult();
        String msg = "";
        ApiLog log = null;
        HttpHeaders headers = new HttpHeaders();
//        try {
//            log = ApiLogAspect.initApiLog("post", url,
//                    json, headers, warehouseCode);
//            log.setWarehouseCode(warehouseCode);
            String result = OkHttpUtils.bodypost(url, json, warehouseCode);
            if (StringUtils.isEmpty(result)) {
                return new SRMResult().error("接口地址错误或服务器连接不到或返回为空");
//                throw new ServiceException("接口地址错误或服务器连接不到或返回为空");
            }
            ajaxResult = JSON.parseObject(result, SRMResult.class);
//        } catch (Exception e) {
//            e.printStackTrace();
////            ApiLogAspect.setApiLogException(log, e);
//        } finally {
////            ApiLogAspect.finishApiLog(log, headers, msg);
//        }
        return ajaxResult;
    }


    //采购到货单返回
    public AjaxResult returnICSPOArrive(List<ICSPOArrive> icspoArrives, String warehouseCode) {
        String json = JSON.toJSONString(icspoArrives);
//        logger.info("WMS送货单确认回传：{}", json);
        Address address = this.getSRMAddress(warehouseCode);
        if (address == null) {
            return AjaxResult.error("未配置SRM API地址");
        }
        String url = address.getUrl() + "POArrive";
        String JsonParam = JSON.toJSONString(icspoArrives);
        logger.info("WMS送货单提交SRM：{}", JsonParam);
        SRMResult srmResult = this.sendReturn(url, JsonParam, warehouseCode);
        logger.info("SRM送货单返回信息：{}", srmResult);
        if (!srmResult.hasError()) {
            return AjaxResult.success(srmResult.getData());
        } else {
            logger.info("SRM采购到货单回传：{}", srmResult.getMessage());
            return AjaxResult.error(srmResult.getMessage());
        }
    }

    //质检返回
    public AjaxResult returnICSinspection(List<ICSinspection> icSinspections, String warehouseCode) {
        String json = JSON.toJSONString(icSinspections);
        logger.info("WMS质检信息回传：{}", json);
        Address address = this.getSRMAddress(warehouseCode);
        if (address == null) {
            return AjaxResult.error("未配置SRM API地址");
        }

        String url = address.getUrl() + "POTest";

        String JsonParam = JSON.toJSONString(icSinspections);
        SRMResult srmResult = this.sendReturn(url, JsonParam, warehouseCode);
        if (!srmResult.hasError()) {
            return AjaxResult.success("成功");
        } else {
            logger.info("SRM质检返回信息：{}", srmResult.getMessage());
            return AjaxResult.error(srmResult.getMessage());
        }
    }


    //入库返回
    public AjaxResult returnICSRuternASN(List<ICSRuternASN> icsRuternASNs, String warehouseCode) {
        String json = JSON.toJSONString(icsRuternASNs);
        logger.info("WMS入库回传：{}", json);
        Address address = this.getSRMAddress(warehouseCode);
        if (address == null) {
            return AjaxResult.error("未配置SRM API地址");
        }

        String url = address.getUrl() + "WareHouseLotInfo";
        String JsonParam = JSON.toJSONString(icsRuternASNs);
        SRMResult srmResult = this.sendReturn(url, JsonParam, warehouseCode);
        if (!srmResult.hasError()) {
            return AjaxResult.success("成功");
        } else {
            logger.info("SRM入库返回信息：{}", srmResult.getMessage());
            return AjaxResult.error(srmResult.getMessage());
        }
    }


    @Transactional
    public AjaxResult delASNAndDetail(List<ICSASN> list) {
        SRMResult srmResult = new SRMResult();
        if (list.isEmpty()) {
            return AjaxResult.error("请勿提交空数据！");
        }

        List<String> STNOS = list.stream().map(ICSASN::getSTNO).collect(Collectors.toList());
        if (STNOS.size() == 0) {
            return AjaxResult.error("送货单号不能为空值！");
        }
        List<String> warehouseCodes = list.stream().map(ICSASN::getWarehouseCode).collect(Collectors.toList());
        if (warehouseCodes.size() == 0) {
            return AjaxResult.error("仓库code不能为空值！");
        }
        // 查询送货单头表
        List<ICSASN> icsasnList = selectBySTNO(STNOS);
        // 差未到送货单头表
        List<SrmHeader> srmHeaderList = srmHeaderService.selectBySTNO(STNOS);
        if (srmHeaderList.size() == 0 || icsasnList.size() == 0) {
            return AjaxResult.success("未查询到送货单信息，请检查送货单号是否正确！");
        }
        for (SrmHeader header : srmHeaderList) {
            // 不是未到货单不允许删除
            if (!QuantityConstant.NO_THE_ARRIVAL.equals(header.getEnable())) {
                return AjaxResult.error("送货单号:" + header.getCode() + "单据已执行不允许删除！");
            }
        }
        // 查询送货单详情表
        List<ICSASNDetail> icsasnDetailList = icsasnDetailService.selectBySTNO(STNOS);
        List<SrmDetail> srmDetailList = srmDetailService.selectBySTNO(STNOS);
        if (icsasnList.size() == srmHeaderList.size() && icsasnDetailList.size() == srmDetailList.size()) {
            try {
                this.removeByIds(icsasnList.stream().map(ICSASN::getID).collect(Collectors.toList()));
                icsasnDetailService.removeByIds(icsasnDetailList.stream().map(ICSASNDetail::getID).collect(Collectors.toList()));
                srmHeaderService.removeByIds(srmHeaderList.stream().map(SrmHeader::getId).collect(Collectors.toList()));
                srmDetailService.removeByIds(srmDetailList.stream().map(SrmDetail::getId).collect(Collectors.toList()));
            } catch (Exception e) {
                // 删除失败事务回滚
                e.printStackTrace();
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return AjaxResult.error("系统异常:" + e.getMessage());
            }

        } else {
            return AjaxResult.error("送货单数据条目不匹配，请检查数据是否正常！");
        }

        return AjaxResult.success("送货单删除成功！");
    }
}