package com.vincent.rsf.server.api.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.cfg.CoercionAction;
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
import com.vincent.rsf.common.domain.CommonReponse;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.config.RemotesInfoProperties;
import com.vincent.rsf.server.api.controller.erp.params.ReportDataParam;
import com.vincent.rsf.server.api.controller.erp.params.ReportParams;
import com.vincent.rsf.server.api.entity.CommonResponse;
import com.vincent.rsf.server.api.entity.constant.RcsConstant;
import com.vincent.rsf.server.api.entity.dto.PoItemsDto;
import com.vincent.rsf.server.api.entity.params.ErpInspectItem;
import com.vincent.rsf.server.api.entity.params.ErpInspectParams;
import com.vincent.rsf.server.api.service.ReportMsgService;
import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.OrderReportStatus;
import com.vincent.rsf.server.manager.enums.OrderType;
import com.vincent.rsf.server.manager.enums.OrderWorkType;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.system.entity.User;
import com.vincent.rsf.server.system.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Ryan
 * @version 1.0
 * @title ReportMsgServiceImpl
 * @description
 * @create 2025/3/12 17:08
 */
@Slf4j
@Service
public class ReportMsgServiceImpl implements ReportMsgService {

    @Autowired
    private PurchaseService purchaseService;
    @Autowired
    private RemotesInfoProperties.ApiInfo apiInfo;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private RemotesInfoProperties remotesInfoProperties;
    @Autowired
    private AsnOrderService asnOrderService;
    @Autowired
    private AsnOrderItemService asnOrderItemService;
    @Autowired
    private RemotesInfoProperties.RcsApi rcsApi;
    @Autowired
    private UserService userService;
    @Autowired
    private StockItemService stockItemService;
    @Autowired
    private StockService stockService;

    /**
     * @author Ryan
     * @description 上报质检列表
     * @params [items 列表]
     *
     * @return boolean
     * @time 2025/3/7 09:12
     * 11
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean reportInspectNotify(List<PoItemsDto> items) {
        if (items.isEmpty()) {
            throw new CoolException("上报内容为空！！");
        }
        List<ErpInspectParams> inspectParams =  new ArrayList<>();
        Map<String, List<PoItemsDto>> listMap = items.stream().collect(Collectors.groupingBy(PoItemsDto::getPurchaseId));
        listMap.keySet().forEach(key -> {
            Purchase purchase = purchaseService.getOne(new LambdaQueryWrapper<Purchase>().eq(Purchase::getId, Long.valueOf(key)));
            if (Objects.isNull(purchase)) {
                throw new CoolException("采购单信息有误！！");
            }
            ErpInspectParams params = new ErpInspectParams();
            List<ErpInspectItem> inspectItems = new ArrayList<>();
            //赋值erp主单编码,编号
            params.setPoId(purchase.getPlatId())
                    .setPoCode(purchase.getPlatCode());
            List<PoItemsDto> dtos = listMap.get(key);
            if (dtos.isEmpty()) {
                throw new CoolException("单据信息错误！！");
            }
            dtos.forEach(dto -> {
                ErpInspectItem inspect= new ErpInspectItem();
                BeanUtils.copyProperties(dto, inspect);
                //赋值erp明细编码
                inspect.setPoItemId(dto.getPlatItemId());
                inspectItems.add(inspect);
            });
            params.setChildren(inspectItems);
            inspectParams.add(params);

        });
        CommonReponse reponse = new CommonReponse();
        if (!remotesInfoProperties.getHost().equals("http://127.0.0.1")){
            MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
            //获取上报质检接口
            String url = remotesInfoProperties.getBaseUrl() + apiInfo.getNotifyInspect();
            // 设置请求参数
            params.add("params", JSONObject.toJSONString(inspectParams));
            log.info("请求地址：{}，请求参数：{}", url, JSONObject.toJSONString(inspectParams));
            HttpHeaders headers = new HttpHeaders();
            headers.add("Content-Type", "application/json");
            HttpEntity httpEntity = new HttpEntity<>(params, headers);
            // 请求
            ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
            log.info("下发任务 返回结果：{}", exchange);
            if (Objects.isNull(exchange.getBody()) || exchange.getBody() == null) {
                throw new CoolException("下发任务失败！！");
            }
            reponse = (CommonReponse) JSON.parse(exchange.getBody());
        }else {
            reponse.setCode(0);
        }


        if (reponse.getCode() == 0) {
            //修改asn上报状态
            Set<String> itemSets = items.stream().map(PoItemsDto::getId).collect(Collectors.toSet());
            Set<Long> longSet = new HashSet<>();
            itemSets.forEach(set -> {
                longSet.add(Long.parseLong(set));
            });

            List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getPoDetlId, longSet));
            if (wkOrderItems.isEmpty()) {
                throw new CoolException("ASN单据不存在！！");
            }
            List<Long> list = wkOrderItems.stream().map(WkOrderItem::getId).collect(Collectors.toList());

            /**************************     修改ASN明细单状态         ******************************/


            if (!asnOrderItemService.update(new LambdaUpdateWrapper<WkOrderItem>().in(WkOrderItem::getId, list).set(WkOrderItem::getNtyStatus, 1))) {
                throw new CoolException("ASN明细单据状态修改失败！！");

            }

            /**************************     修改ASN主单数据         ******************************/
            //获取ASN明细订单标识
            List<Long> ids = wkOrderItems.stream().map(WkOrderItem::getOrderId).collect(Collectors.toList());
            //ASN明细单据分组
            Map<Long, List<WkOrderItem>> asnIds = wkOrderItems.stream().collect(Collectors.groupingBy(WkOrderItem::getOrderId));
            ids.forEach(id -> {
                int count = asnOrderService.count(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, id));
                if (count == asnIds.get(id).size()) {
                    if (!asnOrderService.update(new LambdaUpdateWrapper<WkOrder>().eq(WkOrder::getId, id).set(WkOrder::getNtyStatus, 1))) {
                        throw new CoolException("ASN主单状态修改失败！！");
                    }
                } else {
                    if (!asnOrderService.update(new LambdaUpdateWrapper<WkOrder>().eq(WkOrder::getId, id).set(WkOrder::getNtyStatus, 2))) {
                        throw new CoolException("ASN主单状态修改失败！！");
                    }
                }
            });
            return true;
        } else {
            throw new CoolException(reponse.getMsg());
        }
    }

    /**
     * 上报已完成订单明细
     * @author Ryan
     * @date 2025/10/27 21:36
     * @param params
     * @return com.vincent.rsf.framework.common.R
     */
    @Override
    public R uploadReportOrders(ReportParams params) {
        if (Objects.isNull(params)) {
            throw new CoolException("参数不能为空！！");
        }
        /**WMS基础配置链接*/
        String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.REPORT_ORDERS;
        log.info("上报已完成订单：{}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(params));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        headers.add("api-version", "v2.0");

        HttpEntity httpEntity = new HttpEntity(params, headers);
        ResponseEntity<String> exchange = restTemplate.exchange(rcsUrl, HttpMethod.POST, httpEntity, String.class);
        log.info("上报已完成订单，返回结果： {}", exchange);
        if (Objects.isNull(exchange.getBody())) {
            throw new CoolException("修改失败！！");
        } else {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
            try {
                CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                if (result.getCode() == 200) {
                    return R.ok().add(result.getData());
                } else {
                    return R.ok(result.getMsg()).add(result.getData());
//                    throw new CoolException("修改失败！！");
                }
            } catch (JsonProcessingException e) {
                throw new CoolException(e.getMessage());
            }
        }
    }

    /**
     * 盘点库存数据修改
     * @param params
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R uploadCheckOrder(ReportParams params) {
        if (Objects.isNull(params)) {
            throw new CoolException("参数不能为空！！");
        }
        /**WMS基础配置链接*/
        String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.CHECK_LOCITEM_UPDATE;
        log.info("盘点库存修改：{}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(params));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        headers.add("api-version", "v2.0");

        params.setAction("Update").setOrderType("PD_stock");

        HttpEntity httpEntity = new HttpEntity(params, headers);
        ResponseEntity<String> exchange = restTemplate.exchange(rcsUrl, HttpMethod.POST, httpEntity, String.class);
        log.info("盘点库存修改，返回结果： {}", exchange);
        if (Objects.isNull(exchange.getBody())) {
            throw new CoolException("修改失败！！");
        } else {
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.coercionConfigDefaults().setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
            try {
                CommonResponse result = objectMapper.readValue(exchange.getBody(), CommonResponse.class);
                if (result.getCode() == 200) {
                    return R.ok().add(result.getData());
                } else {
                    throw new CoolException("修改失败！！");
                }
            } catch (JsonProcessingException e) {
                throw new CoolException(e.getMessage());
            }
        }
    }


    /**
     * @author Ryan
     * @date 2025/10/28
     * @description: 上传已完成订单至ERP平台
     * @version 1.0
     */
    @Override
    public void reportOrders(WkOrder order) {
        ReportParams params = new ReportParams();
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, order.getId()));
        if (orderItems.isEmpty()) {
            throw new CoolException("订据明细不存在！！");
        }
        List<ReportDataParam> reportData = new ArrayList<>();
        orderItems.forEach(orderItem -> {
            ReportDataParam param = new ReportDataParam();
            User user = userService.getById(order.getUpdateBy());
            String nickName = null;
            if (!Objects.isNull(user)) {
                nickName = user.getNickname();
            }
            //获取入库库位信息
            if (order.getType().equals(OrderType.ORDER_IN.type)) {
                //筛选当前唯一字段所有出入库信息
                List<StockItem> stockItems = stockItemService.list(new LambdaQueryWrapper<StockItem>()
                        .eq(StockItem::getFieldsIndex, orderItem.getFieldsIndex()));
                //获取库存中订单库位
                if (!stockItems.isEmpty()) {
                    Set<Long> stockIds = stockItems.stream().map(StockItem::getStockId).collect(Collectors.toSet());
                    //获取库存库位信息
                    List<Stock> stocks = stockService.list(new LambdaQueryWrapper<Stock>()
                            .in(Stock::getId, stockIds)
                            .eq(Stock::getType, OrderType.ORDER_IN.type)
                            .eq(Stock::getSourceCode, order.getCode()));
                    Set<String> locs = stocks.stream().map(Stock::getLocCode).collect(Collectors.toSet());
                    String locCode = StringUtils.join(locs.toArray(), ",");
                    param.setZone(locCode);
                }
            }
            //获取索引内容
            Map<String, String> fields = FieldsUtils.getFields(orderItem.getFieldsIndex());

            //设置通用参数
            param.setWMSNO(order.getCode())
                    .setPONO(order.getPoCode())
                    .setOrderNO(order.getPoCode())
                    .setOrderDate(order.getCreateTime())
                    .setItemCode(orderItem.getMatnrCode())
                    .setEditUser(nickName)
                    .setEditDate(order.getUpdateTime())
                    .setGoodsNO(fields.get("crushNo"))
                    .setMemoDtl(order.getMemo());

            if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_DONE_IN.type)) {
                //采购入库单
                params.setOrderType("PO_Instock").setAction("Update");
                //获取指定查询字段CrushNo 票号
                param.setInQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE_RETURN.type)) {
                //采购退货
                params.setOrderType("PR_Outstock").setAction("Update");
                param.setOutQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_TERANSFER.type)) {
                //调拔入库单
                params.setOrderType("Mv_Instock").setAction("Update");

            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD.type)) {
                //生产入库单
//                params.setOrderType("WO_Outstock").setAction("Update");
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE.type)) {
                //生产退料
                params.setOrderType("WR_Instock").setAction("Update");
                param.setInQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_RETURN_ORDER.type)) {
                //生产领料
                params.setOrderType("WO_Outstock").setAction("Update");
                param.setOutQty(orderItem.getQty());

            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD_ADDITION.type)) {
                //生产补料
                params.setOrderType("WR_Instock_BL").setAction("Update");
                param.setOutQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_FIX_OUT.type)) {
                params.setOrderType("WO_Outstock_WR").setAction("Update");
                param.setOutQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_IN.type)) {
                //其它入库单/手动入库单
                params.setOrderType("In_Instock").setAction("Update");
                param.setInQty(orderItem.getQty());

            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER.type)) {
                //其它出库单/手动出库单
                params.setOrderType("Io_Outstock").setAction("Update");
                param.setOutQty(orderItem.getQty());
            }
            reportData.add(param);
        });
        params.setData(reportData);
        try {
            R reported = uploadReportOrders(params);
            if (reported.get("code").equals("200")) {
                order.setNtyStatus(OrderReportStatus.ORDER_REPORT_STATUS_ALL.val);
                asnOrderService.updateById(order);
            }
        } catch (Exception e) {
            log.error("<UNK>", e);
        }

        try {
            //休眠3秒
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}