package com.emato.biz.service.impl;

import java.io.IOException;
import java.util.*;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.emato.biz.config.OmsConfig;
import com.emato.biz.domain.OutRequest;
import com.emato.biz.domain.merchant.MerchUser;
import com.emato.biz.domain.merchant.ThirdMerchantBiz;
import com.emato.biz.domain.warehouse.Page;
import com.emato.biz.domain.warehouse.PullInveQueryVO;
import com.emato.biz.mapper.merchant.MerchUserMapper;
import com.emato.biz.mapper.merchant.ThirdMerchantBizMapper;
import com.emato.biz.mapper.warehouse.WbInveMngMapper;
import com.emato.biz.util.JsonUtil;
import com.emato.biz.util.OmsDataUtil;
import com.emato.biz.util.RoleUtils;
import com.emato.common.core.Result;
import com.emato.common.core.domain.AjaxResult;
import com.emato.common.core.domain.entity.SysUser;
import com.emato.common.exception.ServiceException;
import com.emato.common.utils.DateUtils;
import com.emato.common.utils.SecurityUtils;
import com.emato.common.utils.oms.JacksonUtils;
import com.emato.common.utils.oms.request.OmsSign;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.emato.biz.mapper.warehouse.OWbInveMngMapper;
import com.emato.biz.domain.warehouse.OWbInveMng;
import com.emato.biz.service.warehouse.IOWbInveMngService;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * 库存管理，wms入库回传时，增加库存数Service业务层处理
 *
 * @author yangbo
 * @date 2021-02-01
 */
@Service
public class OWbInveMngServiceImpl implements IOWbInveMngService
{
    @Resource
    private OWbInveMngMapper oWbInveMngMapper;

    @Resource
    private WbInveMngMapper wbInveMngMapper;

    @Resource
    private MerchUserMapper merchUserMapper;

    @Resource
    private ThirdMerchantBizMapper thirdMerchantBizMapper;

    private static final Logger log = LoggerFactory.getLogger(OWbInveMngServiceImpl.class);

    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;

    /**
     * 根据条件拉取 OMS 数据
     *
     * @param queryVO
     * @return
     */
    @Override
    public AjaxResult pullInveMng(PullInveQueryVO queryVO) {
        // 声明页数
        int page = 1;
        // 处理查询参数
        setQueryVO(queryVO, page, OmsConfig.getQuerySize());

        // 声明处理数量
        AtomicInteger rows = new AtomicInteger(0);
        // 查询 OMS 分页数据
        Optional<Page<OWbInveMng>> firstPageOpt =
                OmsDataUtil.fetchOmsPageData(queryVO, OmsConfig.getQueryMngInveUrl(), OWbInveMng.class);

        // 如果有数据
        firstPageOpt.ifPresent(firstPage -> {
            // 插入数据库
            firstPage.getList().stream().forEach(obj -> {
                // 插入数据库
                wbInveMngMapper.saveOrUpdate(obj);
                // 处理数据条数加 1
                rows.getAndIncrement();
            });

            for(int pageNum = page + 1; pageNum <= firstPage.getTotalPage(); pageNum++) {
                log.debug("当前拉取的页数 => {}", pageNum);
                queryVO.setPage(pageNum);
                // 分页拉取远程数据
                Optional<Page<OWbInveMng>> pageOpt = OmsDataUtil.fetchOmsPageData(queryVO, OmsConfig.getQueryMngInveUrl(), OWbInveMng.class);
                pageOpt.get().getList().forEach(obj -> {
                    wbInveMngMapper.saveOrUpdate(obj);
                    rows.getAndIncrement();
                });
            }

        });

        log.debug("拉取库存成功，拉取数据条数 => {}", rows.get());
        return AjaxResult.success("拉取库存成功!");
    }

    /**
     * 查询库存管理，wms入库回传时，增加库存数
     *
     * @param inveSn 库存管理，wms入库回传时，增加库存数ID
     * @return 库存管理，wms入库回传时，增加库存数
     */
    @Override
    public OWbInveMng selectOWbInveMngById(String inveSn)
    {
        return oWbInveMngMapper.selectOWbInveMngById(inveSn);
    }

    /**
     * 查询库存管理，wms入库回传时，增加库存数列表
     *
     * @param oWbInveMng 库存管理，wms入库回传时，增加库存数
     * @return 库存管理，wms入库回传时，增加库存数
     */
    @Override
    public List<OWbInveMng> selectOWbInveMngList(OWbInveMng oWbInveMng)
    {
        // 获取登录用户
        SysUser user = SecurityUtils.getLoginUser().getUser();
        boolean allRole = RoleUtils.isAllRole(user);

        if (!allRole) {
            // 如果没有全部数据权限
            // 查询该用户属于哪个商户
            MerchUser merchUser = merchUserMapper.selectMerchUserByUserId(user.getUserId()+"");
            if (Objects.isNull(merchUser)) {
                // 如果用户没有绑定商户就返回空数据
                return Collections.emptyList();
            }

            // 如果用户绑定了商户
            // 获取用户绑定的商户号，开始查询该商户的库存数据
            String merchSn = merchUser.getMerchSn();
            // 设置商户作为查询条件
            oWbInveMng.setMerchSn(merchSn);

            // 查询是否有三方商户
            ThirdMerchantBiz merchantBiz = thirdMerchantBizMapper.selectByClientMerchSn(merchSn);
            if (Objects.nonNull(merchantBiz)) {
                // 如果有第三方商户，设置三方商户号作为查询条件
                oWbInveMng.setThirdMerchSn(merchantBiz.getThirdMerchSn());
            }
        }

        return wbInveMngMapper.selectWbInveMngList(oWbInveMng);
    }

    /**
     * 新增库存管理，wms入库回传时，增加库存数
     *
     * @param oWbInveMng 库存管理，wms入库回传时，增加库存数
     * @return 结果
     */
    @Override
    public int insertOWbInveMng(OWbInveMng oWbInveMng)
    {
        oWbInveMng.setCreateTime(DateUtils.getNowDate());
        return oWbInveMngMapper.insertOWbInveMng(oWbInveMng);
    }

    /**
     * 修改库存管理，wms入库回传时，增加库存数
     *
     * @param oWbInveMng 库存管理，wms入库回传时，增加库存数
     * @return 结果
     */
    @Override
    public int updateOWbInveMng(OWbInveMng oWbInveMng)
    {
        return oWbInveMngMapper.updateOWbInveMng(oWbInveMng);
    }

    /**
     * 批量删除库存管理，wms入库回传时，增加库存数
     *
     * @param inveSns 需要删除的库存管理，wms入库回传时，增加库存数ID
     * @return 结果
     */
    @Override
    public int deleteOWbInveMngByIds(String[] inveSns)
    {
        return oWbInveMngMapper.deleteOWbInveMngByIds(inveSns);
    }

    /**
     * 删除库存管理，wms入库回传时，增加库存数信息
     *
     * @param inveSn 库存管理，wms入库回传时，增加库存数ID
     * @return 结果
     */
    @Override
    public int deleteOWbInveMngById(String inveSn)
    {
        return oWbInveMngMapper.deleteOWbInveMngById(inveSn);
    }

    /**
     * 根据商户编号去拉取数据
     *
     * @param merchSn
     * @return
     */
    @Override
    @Transactional
    public int pullInveMng(String merchSn) {
        int page = 1;
        Integer querySize = OmsConfig.getQuerySize();
        int resultCode = pullInveMngFromOms(merchSn,page, querySize);
        while(resultCode != 1){
            page = page + 1;
            resultCode = pullInveMngFromOms(merchSn, page, querySize);
        }
        return resultCode==0?1:resultCode;
    }

    private int pullInveMngFromOms(String merchSn, int page, Integer querySize) {


        Map<String,String> data = new HashMap();
        data.put("merchId",merchSn);
        data.put("page",page+"");
        data.put("limit",querySize.toString());


        Map sParaTemp = new TreeMap();
        sParaTemp.put("data", JSON.toJSONString(data));
        sParaTemp.put("merchId",OmsConfig.getMerchSn());
        String timestamp = String.valueOf(System.currentTimeMillis()/1000);
        sParaTemp.put("timestamp", timestamp);
        //生成要请求给oms秘钥
        log.info("md5混淆码参数:" + OmsConfig.getMd5Salt());
        String sign = OmsSign.sign(sParaTemp,OmsConfig.getMd5Salt());
        sParaTemp.put("sign", sign);
        //构建Request
        String  url = OmsConfig.getQueryMngInveUrl();
        String jsonParam = JSONObject.toJSONString(sParaTemp);
        log.info("Eccs 请求 OMS url => {}, 请求 OMS 报文 => {}", url, jsonParam);

        // 同步访问,返回结果字符串
        String responseString = null;
        try {
            JSONObject jsonObject = httpPost(url,JSONObject.parseObject(jsonParam));

            log.info("oms的响应报文"+jsonObject.toString());

            //解析响应数据
            JSONArray result = (JSONArray) jsonObject.get("data");
            Object msg = jsonObject.get("msg");
            Object code = jsonObject.get("code");

            if(result == null || result.size() == 0){
                return 1;
            }


            for(int i = 0 ; i < result.size(); i ++){

                JSONObject o = (JSONObject) result.get(i);
                OWbInveMng oWbInveMng = o.toJavaObject(OWbInveMng.class);
                //oWbInveMngMapper.saveOrUpdate(oWbInveMng);
                wbInveMngMapper.saveOrUpdate(oWbInveMng);
            }

            if("202".equals(code)){
                return 1;
            }

        } catch (Exception e) {
            log.error(e.getMessage());
            return 1;
        }


        return 0;
    }


    public static JSONObject httpPost(String url, JSONObject jsonParam)
    {
        // post请求返回结果
        CloseableHttpClient httpClient = HttpClients.createDefault();
        JSONObject jsonResult = null;
        HttpPost httpPost = new HttpPost(url);
        // 设置请求和传输超时时间
//        httpPost.setConfig(requestConfig);
        try
        {
            if (null != jsonParam)
            {
                // 解决中文乱码问题
                StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");
                entity.setContentEncoding("UTF-8");
                entity.setContentType("application/json");
                httpPost.setEntity(entity);
            }
            CloseableHttpResponse result = httpClient.execute(httpPost);
            // 请求发送成功，并得到响应
            if (result.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
            {
                String str = "";
                try
                {
                    // 读取服务器返回过来的json字符串数据
                    str = EntityUtils.toString(result.getEntity(), "utf-8");
                    // 把json字符串转换成json对象
                    jsonResult = JSONObject.parseObject(str);
                }
                catch (Exception e)
                {
                    log.error("post请求提交失败:" + url, e);
                }
            }
        }
        catch (IOException e)
        {
            log.error("post请求提交失败:" + url, e);
        }
        finally
        {
            httpPost.releaseConnection();
        }
        return jsonResult;
    }

    /**
     * 拉取 OMS 库存数据
     *
     * @param queryVO 请求 OMS 数据
     * @param url 请求 OMS 地址
     * @param clazz 返回的分页数据类
     *
     * @return
     */
    private <T> Optional<Page<T>> fetchOmsPageData(PullInveQueryVO queryVO,
                                               String url,
                                               Class<T> clazz) {
        // 构建请求报文
        // 初始化请求 oms 参数 Map
        Map<String, String> reqOmsPram = new TreeMap<>();
        // 请求 oms 数据
        reqOmsPram.put("===== data ====> {}", JacksonUtils.toJsonStr(queryVO));
        // 请求 oms 商户号
        reqOmsPram.put("merchId", OmsConfig.getMerchSn());
        log.debug("===== 请求 oms 商户号 ====> {}", OmsConfig.getMerchSn());
        // 请求 oms 时间戳
        String timestamp = System.currentTimeMillis()/1000 + "";
        reqOmsPram.put("timestamp", timestamp);
        log.debug("===== 请求 oms 时间戳 ====> {}", timestamp);
        // 请求 oms 签名
        String sign = OmsSign.sign(reqOmsPram, OmsConfig.getMd5Salt());
        reqOmsPram.put("sign", sign);
        // oms 请求地址
        log.debug("===== 请求 oms 地址 ====> {}", url);
        // 请求 oms 报文
        String reqBody = JacksonUtils.toJsonStr(reqOmsPram);
        log.debug("===== 请求 oms 报文 ====> {}", reqBody);

        // oms 返回数据
        String body = null;
        try {
            body = HttpRequest.post(url)
                    .body(JacksonUtils.toJsonStr(reqOmsPram))
                    .execute()
                    .body();
        } catch (Exception e) {
            throw new ServiceException("请求 OMS 异常!");
        }
        log.debug("OMS 响应信息 => {}", body);

        // 解析返回的数据
        JSONObject jsonObject = JSONObject.parseObject(body);
        String code = jsonObject.getString("code");

        if ("200".equals(code)){
            Page<T> page = JsonUtil.parsePage(jsonObject, clazz);
            if (!page.getList().isEmpty())
                // 如果 page 有值就返回
                return Optional.of(page);
        }

        return Optional.empty();
    }

    /**
     * 处理查询参数
     *
     * @param queryVO
     * @param page
     * @param limit
     */
    private void setQueryVO(PullInveQueryVO queryVO, int page, int limit) {
        queryVO.setPage(page);
        queryVO.setLimit(limit);

        // 查询是否是三方商户
        ThirdMerchantBiz thirdMerchantBiz = thirdMerchantBizMapper.selectByClientMerchSn(queryVO.getMerchId());
        if (Objects.nonNull(thirdMerchantBiz)) {
            // 如果是三方商户，查询条件加入三方商户
            queryVO.setThirdMerchId(thirdMerchantBiz.getThirdMerchSn());
        }

        // 将 sku 变成 skuSet 参数
        if (StrUtil.isNotBlank(queryVO.getSku())) {
            List<String> skus = StrUtil.split(queryVO.getSku(), ",");
            Set<String> skuSet = skus.stream().collect(Collectors.toSet());
            queryVO.setSkuSets(skuSet);
        }

        // 将门店编号转为门店列表
        if (StrUtil.isNotBlank(queryVO.getShopSn())) {
            List<String> shopList = StrUtil.split(queryVO.getShopSn(), ",");
            queryVO.setShopSnList(shopList);
        }
    }

}