package com.caimei.controller.order;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.caimei.entity.*;
import com.caimei.service.order.OrderService;
import com.caimei.service.user.LoginService;
import com.caimei.utils.HttpRequest;
import com.caimei.utils.JsonMapper;
import com.github.pagehelper.PageHelper;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 订单
 */
@Controller
@RequestMapping("/order")
public class OrderController {
    protected static final Logger logger = LoggerFactory.getLogger(OrderController.class);

    @Autowired
    private OrderService orderService;
    @Autowired
    private LoginService loginService;
    @Autowired
    private Environment env;

    /**
     * 确认订单信息
     *
     * @return
     */
    @ResponseBody
    @RequestMapping("/confirm")
    public CmWxJsonModel confirmOrder(Integer userId, String classifyIDS, Integer organizeID, String productIDs, Integer count) {
        Map<String, Object> map = orderService.confirmOrder(userId, classifyIDS, organizeID, productIDs, count);
        return CmWxJsonModel.newInstance().success(map);
    }

    /**
     * 分享订单
     *
     * @return
     */
    @ResponseBody
    @RequestMapping("/share")
    public CmWxJsonModel shareOrder(Integer orderID) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        String shareCode = null;
        try {
            shareCode = orderService.shareOrder(orderID);
        } catch (Exception e) {
            return model.error("" + e.getMessage());
        }
        return model.success(shareCode);
    }

    /**
     * 分享订单,分享码验证通过
     */
    @ResponseBody
    @RequestMapping("/shareCode")
    public CmWxJsonModel verifyShareCode(String shareCode, String code, Integer orderID, Integer userID,
                                         Integer organizeID, HttpServletRequest request) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        logger.info("Start get SessionKey");
        Map<String, Object> map = new HashMap<>();
        String referer = request.getHeader("Referer"); //获取当前微信小程序的环境
        logger.info("referer-is----:" + referer);
        map.put("referer", referer);
        String requestUrl = "https://api.weixin.qq.com/sns/jscode2session";
        Map<String, String> requestUrlParam = new HashMap<String, String>();
        requestUrlParam.put("appid", env.getProperty("miniprogram.AppId" + organizeID));//小程序appId
        requestUrlParam.put("secret", env.getProperty("miniprogram.AppSecret" + organizeID));//小程序appsecret
        requestUrlParam.put("js_code", code);//小程序端返回的code
        requestUrlParam.put("grant_type", "authorization_code");//默认参数
        //发送post请求读取调用微信接口获取openid用户唯一标识
        String infos;
        try {
            infos = HttpRequest.sendPost(requestUrl, requestUrlParam);
        } catch (Exception e) {
            model.setData(map);
            return model.error("服务器内部异常");
        }
        //解析相应内容（转换成json对象）
        JSONObject jsonObject = JSON.parseObject(infos);
        String openid = jsonObject.getString("openid");
        logger.info("openid----->" + openid);
        String session_key = jsonObject.getString("session_key");
        String errcode = jsonObject.getString("errcode");
        String errmsg = jsonObject.getString("errmsg");
        if (!org.springframework.util.StringUtils.isEmpty(errcode) &&
                (errcode.equals("-1") || errcode.equals("40029") || errcode.equals("45011"))) {
            model.setMsg(errmsg);
            model.setData(map);
            map.put("sessionKey", session_key);
            model.setCode("-1");
            return model;
        }
        if (orderID == null || userID == null || organizeID == null) {
            model.error("参数异常");
        }
        CmWxJsonModel jsonModel = orderService.verifyShareCode(shareCode, openid, orderID, userID, organizeID);
        return jsonModel;
    }

    /**
     * 订单详情
     */
    @ResponseBody
    @RequestMapping("/particulars")
    public CmWxJsonModel particulars(Integer orderID) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        Map<String, Object> map = null;
        try {
            map = orderService.particulars(orderID);
        } catch (Exception e) {
            return model.error("" + e.getMessage());
        }
        return model.success(map);
    }

    /**
     * 提交订单接口
     *
     * @return code:-1=(用户账户异常,数据异常,操作异常等)，1提交成功（支付完成）,2提交成功(未支付)，code为1和2的情况下出现 data{orderNo:订单号，orderID:订单ID,payTotalFee:订单金额，orderMark：订单标识}
     * @Param params参数格式：
     * 参数1=userId用户ID
     * 参数2=organizeID组织ID，
     * 参数3=cartType购买类型（1购物车提交，2直接购买提交）
     * 参数4=ddressID订单收货地址
     * 参数5=orderInfo订单信息参数格式：
     * [
     * {"shopId":1001,
     * "note":81,
     * "productInfo":[{"productId":1,"productNum":80},{"productId":2,"productNum":100}]
     * }
     * ]
     * 参数6=balanceDeductionFlag是否使用余额抵扣(1使用，2不使用)
     * 参数7=orderShouldPayFee订单应付金额（商品总金额 - 余额抵扣 - 经理折扣默认为0）
     */
    @Transactional
    @ResponseBody
    @RequestMapping("/submitOrder")
    public synchronized CmWxJsonModel submitOrder(String params, HttpServletRequest request) {
        CmWxJsonModel cmWxJsonModel = CmWxJsonModel.newInstance();
        logger.info(">>>>>>订单信息params:" + params);
        //检查用户是否登入
//        CmMallOperationUser currentUser = SessionHelper.getCurrentUser(request);
        HttpSession session = request.getSession();
        String openid = (String) session.getAttribute("openid");
        Integer organizeID1 = (Integer) session.getAttribute("organizeID");
        CmMallOperationUser currentUser = loginService.doLogin(openid, organizeID1);
        if (null == currentUser) {
            return cmWxJsonModel.error("-1", "用户账户异常");
        }
        Integer cmOperationID = currentUser.getId();//当前操作者ID
        if (StringUtils.isBlank(params)) {
            return cmWxJsonModel.error("-1", "数据异常");
        }
        Map<String, Object> map = new HashMap<String, Object>();
        try {
            map = (Map<String, Object>) JsonMapper.getInstance().fromJsonString(params, Map.class);
            if (null == map) {
                logger.info(">>>>>数据异常，参数不能为空");
                return cmWxJsonModel.error("-1", "数据异常");
            }
            Integer userId = (Integer) map.get("userId");
            Integer organizeID = (Integer) map.get("organizeID");
            String cartType = String.valueOf(map.get("cartType"));
            Integer addressID = (Integer) map.get("addressID");
            Object orderInfo = map.get("orderInfo");
            String balanceDeductionFlag = String.valueOf(map.get("balanceDeductionFlag"));
            Double orderShouldPayFee = Double.parseDouble(String.valueOf(map.get("orderShouldPayFee")));//此金额为前端计算，适用于后端计算金额复查
            //校验传入参数的正确性
            if (null == userId) {
                return cmWxJsonModel.error("-1", "用户数据异常");
            }
            if (null == organizeID) {
                return cmWxJsonModel.error("-1", "组织数据异常");
            }
            if (StringUtils.isEmpty(cartType)) {
                return cmWxJsonModel.error("-1", "购买类型数据异常");
            }
            if (null == addressID) {
                return cmWxJsonModel.error("-1", "地址数据异常");
            }
            if (null == orderInfo) {
                return cmWxJsonModel.error("-1", "订单数据异常");
            }
            if (StringUtils.isEmpty(balanceDeductionFlag)) {
                return cmWxJsonModel.error("-1", "余额抵扣数据异常");
            }
            if (null == orderShouldPayFee) {
                return cmWxJsonModel.error("-1", "订单应付金额数据异常");
            }
            //保存订单信息
            return orderService.saveOrderInfo(cmWxJsonModel, userId, organizeID, cartType, addressID, orderInfo, balanceDeductionFlag, orderShouldPayFee, cmOperationID);
        } catch (Exception e) {
            logger.info(">>>>>系统异常" + e.getMessage());
            return cmWxJsonModel.error("-1", "数据异常");

        }
    }

    /**
     * 物流详情
     */
    @ResponseBody
    @RequestMapping("/logistics")
    public CmWxJsonModel logistics(Integer orderID) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        List<CmMallLogisticsBatch> logistics = null;
        try {
            logistics = orderService.logistics(orderID);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return model.success(logistics);
    }

    /**
     * 查询我的订单
     *
     * @param orderState 订单状态
     * @return
     */
    @ResponseBody
    @RequestMapping("/myOrder")
    public CmWxJsonModel myOrder(Integer orderState, Integer userID, Integer index, Integer pageSize, Integer organizeID) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        if (userID == null || orderState == null || organizeID == null) return model.error("参数异常");
        if (index == null) index = 1;
        if (pageSize == null) pageSize = 10;
        PageHelper.startPage(index, pageSize);
        List<CmMallOrder> orderList = orderService.myOrder(userID, orderState, organizeID);
        CmMallPage<CmMallOrder> page = new CmMallPage<>(orderList);
        return model.success(page);
    }

    /**
     * 常采购商品
     */
    @ResponseBody
    @RequestMapping("/purchase")
    public CmWxJsonModel oftenPurchase(Integer userID, Integer organizeID, Integer index, Integer pageSize) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        if (userID == null || organizeID == null) return model.error("参数异常");
        Map<String, Object> map = orderService.oftenPurchase(userID, organizeID, index, pageSize);
        return model.success(map);
    }

    /**
     * 删除订单
     */
    @ResponseBody
    @RequestMapping("/delete")
    public CmWxJsonModel deleteOrder(Integer orderID) {
        CmWxJsonModel model = null;
        try {
            model = orderService.deleteOrder(orderID);
        } catch (Exception e) {
            return model.error("删除订单失败," + e.getMessage());
        }
        return model;
    }

    /**
     * 取消订单
     */
    @ResponseBody
    @RequestMapping("/cancel")
    public CmWxJsonModel cancelOrder(Integer orderID) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        try {
            orderService.cancelOrder(orderID);
        } catch (Exception e) {
            return model.error("" + e.getMessage());
        }
        return model.success("取消订单成功", "");
    }

    /**
     * 确认收货
     */
    @ResponseBody
    @RequestMapping("/affirm")
    public CmWxJsonModel affirmCargo(Integer orderID) {
        CmWxJsonModel model = CmWxJsonModel.newInstance();
        try {
            orderService.affirmCargo(orderID);
        } catch (Exception e) {
            return model.error("" + e.getMessage());
        }
        return model.success("确认收货成功", "");
    }
}