package com.rnt.service;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;

import com.jfinal.aop.Before;
import com.jfinal.aop.Duang;
import com.jfinal.log.Log;
import com.jfinal.plugin.activerecord.Db;
import com.jfinal.plugin.activerecord.tx.Tx;
import com.rnt.commo.enums.DSEnum;
import com.rnt.commo.enums.DataStatusEnum;
import com.rnt.commo.enums.OrderTypeEnum;
import com.rnt.commo.enums.PayOrderEnum;
import com.rnt.commo.enums.SequenceTypeEnum;
import com.rnt.model.zf.CardCoupons;
import com.rnt.model.zf.Order;
import com.rnt.model.zf.OrderDetailCard;
import com.rnt.model.zf.ParkOrderFlow;
import com.rnt.model.zf.PayOrder;
import com.rnt.utils.DateUtil;
import com.rnt.utils.SequenceUtil;
import com.rnt.vo.OrderVO;
import org.beetl.sql.core.kit.StringKit;

public class OrderService {

    IRainQueryService iRainQueryService = Duang.duang(IRainQueryService.class);

    private static final Log logger = Log.getLog(OrderService.class);

    /**
     * 支付成功后调用的函数
     *
     * @param payOrderId 支付单ID
     * @return 是否成功
     */
    @Before(Tx.class)
    public Boolean payOrderSuccess(String payOrderId,String transId) {
        logger.info("========支付成功后，修改单据状态==== start ====");
        logger.info("========支付成功后，修改单据状态  入参为:payOrderId="+payOrderId+"; transId="+transId);
        //修改支付单状态
        PayOrder payOrder = PayOrder.dao.findFirst("select * from td_b_pay_order t where t.pay_order_id = ?", payOrderId);
        payOrder.setPayOrderState(Integer.valueOf(PayOrderEnum.PAY_ORDER_STATE_PAY_SUCCESS.getValue()));
        //微信端的订单交易流水
        payOrder.setRltPayOrderId(transId);
        boolean flag = payOrder.update();
        logger.info("修改支付单，flag状态为: flag=" + flag);
        String orderId = payOrder.getRltOrderId();
        //修改订单状态
        Order order = Order.dao.findFirst("select * from td_b_order t where t.order_id = ?", orderId);
        order.setOrderState(OrderTypeEnum.ORDER_TYPE_3.value());
         flag = flag & order.update();
        logger.info("修改订单，flag状态为: flag=" + flag);

        //查询订单明细表
        OrderDetailCard orderDetailCard = OrderDetailCard.dao.findFirst(
            "select * from td_b_order_detail_card t where t.order_id = ?", orderId);

        Integer orderDetailType = orderDetailCard.getOrderDetailType();
        Long cardCoponsId = orderDetailCard.getPersonCardId();
        CardCoupons cardCoupons = CardCoupons.dao.findById(cardCoponsId);

        Integer orderType = order.getOrderType();

        if(OrderTypeEnum.PARK_ORDER_TYPE_1.value().equals(orderType)){
            /**停车订单*/
            /** 上面已将订单状态修改为已支付，无需后续操作了*/
            logger.info("停车订单修改，将订单状态修改为已支付");


        }else if(OrderTypeEnum.PARK_ORDER_TYPE_2.value().equals(orderType) || OrderTypeEnum.PARK_ORDER_TYPE_3.value().equals(orderType)){
            /**年卡、月卡订单*/
            if (OrderTypeEnum.ORDER_DETAIL_TYPE_BUY_CARD.value().equals(orderDetailType)) {
                /**购卡单*/
                cardCoupons.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
                flag = flag & cardCoupons.update();
                logger.info("购卡单修改数据状态，flag状态为: flag=" + flag);
            } else if (OrderTypeEnum.ORDER_DETAIL_TYPE_RENEW_CARD.value().equals(orderDetailType)) {
                /**续费单*/
                //1、 从订单明细表中获取失效日期
                Date expDate = orderDetailCard.getExpDate();
                //2、更改个人卡卷表失效日期
                cardCoupons.setExpDate(expDate);
                flag = flag & cardCoupons.update();
                logger.info("支付单修改数据状态，flag状态为: flag=" + flag);
            } else {
                logger.info("无法识别的订单类型 orderDetailType=" + orderDetailType);
            }
        }else{
            logger.info("无法识别的订单类型 orderType=" + orderType);
        }


        logger.info("========支付成功后，修改单据状态==== end  ====");
        return flag;
    }

    /**
     * 查询支付成功的历史车牌,最多3个.<br/>
     *
     * @param custId 个人客户id
     * @return
     */
    public List<String> queryHistoryCarNum(String custId) {
        List<String> list = new ArrayList<String>();
        StringBuffer sql = new StringBuffer("select  a.car_number");
        sql.append(" from td_b_order a  ");
        sql.append(" where a.order_state in(3,4) ");
        sql.append(" and cust_person_id= ? ");
        sql.append(" group by a.car_number,a.create_date");
        sql.append(" order by a.create_date desc ");
        sql.append(" limit 0,3 ");
        List<Order> orderList = new Order().find(sql.toString(), custId);

        if (orderList != null && orderList.size() > 0) {
            for (Order order : orderList) {
                list.add(order.getCarNumber());
            }
        }

        return list;
    }

    /**
     * 查询待支付的停车订单.<br/>
     * 步骤：
     * 1.查询待支付的订单
     * 1.调用艾润接口查询费用.<br/>
     * 3.更新订单费用.<br/>
     * 4.更新订单明细费用.<br/>
     * 5.插入订单流水表.
     *
     * @param carNum
     * @throws ParseException
     */
    public OrderVO queryParkOrderForNotPay(String carNum) throws ParseException {
        logger.info("开始查询待支付单信息,carNum=" + carNum);
        OrderVO orderVO = new OrderVO();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        String irunResult = "";
        //1.查询待支付订单
        Order order = this.findOrderByCarNum(carNum);
        //2.调用艾润接口
        if (order != null && StringKit.isNotBlank(order.getParkId())) {
            irunResult = iRainQueryService.billQuery(carNum, order.getParkId());
        } else {
            logger.info("查询订单失败");
        }
        boolean orderUpdateFlg = false;
        int updateOrderDetailFlg = 0;
        //3.更新订单
        if (StringKit.isNotBlank(irunResult) && !"NO_PARK_RECORD".equals(JSONObject.parseObject(irunResult).get("code"))) {
            Map<String, String> map = jsonToMapForIrunResult(irunResult);
            Order updateOrder = new Order();

            if (map != null && map.size() > 0) {
                updateOrder.setId(order.getId());
                updateOrder.setOrderId(order.getOrderId());
                updateOrder.setOrderType(Integer.valueOf(PayOrderEnum.PAY_RESOURCE_TYPE_PARK.getValue()));
                updateOrder.setOrderState(Integer.valueOf(OrderTypeEnum.ORDER_TYPE_2.value()));
                updateOrder.setOrderPayedFee(new BigDecimal(map.get("order_payed_fee")));
                updateOrder.setOrderNotPayFee(new BigDecimal(map.get("order_not_pay_fee")));
                updateOrder.setOrderTotalFee(new BigDecimal(map.get("order_total_fee")));
                updateOrder.setModfiyDate(new Date());
                /**更新订单表.*/
                orderUpdateFlg = updateOrder.update();
            } else {
                logger.info("没有查询到费用信息");
            }

            if (orderUpdateFlg) {
                StringBuffer sqls = new StringBuffer("update td_b_order_detail_park a ");
                sqls.append("set a.order_id =?,");
                sqls.append("a.record_id=?,");
                sqls.append("a.park_in_time=?,");
                sqls.append("a.park_out_time =?,");
                sqls.append("a.parking_duration=?,");
                sqls.append("a.modfiy_date= ?,");
                sqls.append("a.remark= '查询费用后更新'");
                sqls.append(" where a.order_id =?");

                /**更新订单明细表.*/
                updateOrderDetailFlg = Db.use(DSEnum.ZF_DATASOURCE.name()).update(sqls.toString(),
                    order.getOrderId(),
                    map.get("record_id"),
                    format.parse(map.get("park_in_time")),
                    format.parse(map.get("park_out_time")),
                    Long.valueOf(map.get("parking_duration")),
                    new Date(),
                    order.getOrderId());
                if (updateOrderDetailFlg <= 0) {
                    logger.info("更新订单子表失败");
                } else {
                    //封装返回数据
                    orderVO.setOrderId(order.getOrderId());
                    orderVO.setParkId(order.getParkId());
                    orderVO.setParkName(map.get("park_name"));
                    orderVO.setParkAddress(map.get("park_address"));
                    orderVO.setCarNumber(order.getCarNumber());
                    orderVO.setOrderPayedFee(new BigDecimal(map.get("order_payed_fee")));
                    orderVO.setOrderNotPayFee(new BigDecimal(map.get("order_not_pay_fee")));
                    orderVO.setOrderTotalFee(new BigDecimal(map.get("order_total_fee")));
                    orderVO.setOrderTitle("待付费用");
                    orderVO.setParkInTime(format.parse(map.get("park_in_time")));
                    orderVO.setParkOutTime(format.parse(map.get("park_out_time")));
                    orderVO.setParkingDuration(DateUtil.secondToTime(Long.valueOf(map.get("parking_duration"))));
                }
                ParkOrderFlow parkOrderFlow = new ParkOrderFlow();
                parkOrderFlow.setParkOrderFolwId(SequenceUtil.getNextOrderId(SequenceTypeEnum.ORDER_PARK_FLOW.value()));
                parkOrderFlow.setParkOrderId(order.getOrderId());
                parkOrderFlow.setProcTime(new Date());
                parkOrderFlow.setProcResult(1);
                parkOrderFlow.save();

            } else {
                logger.info("更新订单失败");
            }
        }
        logger.info("结束查询待支付单信息");
        return orderVO;
    }

    /**
     * 获取查询费用返回结果.<br/>
     *
     * @param json
     * @return
     */
    private Map<String, String> jsonToMapForIrunResult(String json) {

        JSONObject jsobj = JSONObject.parseObject(json);
        Map<String, String> map = new HashMap<String, String>();
        if (jsobj != null) {
            if (!jsobj.get("status").toString().equals("0")) {
                JSONObject data = (JSONObject)jsobj.get("data");
                // 出场时间对象
                JSONObject parkOutObject = (JSONObject)data.get("out");
                //停车记录id
                map.put("record_id", data.getString("id"));
                // 出场时间
                map.put("park_out_time", parkOutObject.getString("time"));
                if (data.get("park") != null) {
                    map.put("park_name", JSONObject.parseObject(data.get("park").toString()).get("name") + "");
                    map.put("park_address", JSONObject.parseObject(data.get("park").toString()).get("address") + "");
                }

                //入场时间
                if (data.get("in") != null) {
                    map.put("park_in_time", JSONObject.parseObject(data.get("in").toString()).getString("time"));
                }
                //总费用
                map.put("order_total_fee", JSONObject.parseObject(data.get("charge").toString()).getString("due"));
                //已付费用
                map.put("order_payed_fee", JSONObject.parseObject(data.get("charge").toString()).getString("paid"));
                //未支付费用(本次应付金额)
                map.put("order_not_pay_fee", JSONObject.parseObject(data.get("charge").toString()).getString("unpaid"));
                //停车时长  单位：秒
                map.put("parking_duration",
                    JSONObject.parseObject(data.get("charge").toString()).getString("duration"));
            }
        }
        return map;
    }

    /**
     * 通过车牌查询待核算支付单信息.<br/>
     *
     * @param
     */
    public Order findOrderByCarNum(String carNum) {
        //1.查询待支付订单
        StringBuffer sql = new StringBuffer(
            "select a.id, a.order_id,a.car_number,a.order_title,a.order_payed_fee,a.order_not_pay_fee,a"
                + ".order_total_fee,a.park_id");
        sql.append(" from td_b_order a");
        sql.append(" where a.order_state in(1,2,3)");
        sql.append(" and a.car_number=?");
        sql.append(" order by a.create_date DESC");

        Order order = new Order().findFirst(sql.toString(), carNum);
        
        

        return order;
    }


}