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.OrderDetailPark;
import com.rnt.model.zf.ParkOrderFlow;
import com.rnt.model.zf.PayOrder;
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);
        //推送状态：1已推送，0：未推送
        //将卡卷信息推送状态设置为0: 未推送
        cardCoupons.setPushState(0);
        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;
    }

    /**
     * 通过订单好
     *
     * @param orderId
     * @return
     */
    public OrderDetailPark queryDetailParkByOrderId(String orderId) {
        StringBuffer sql = new StringBuffer("select order_id,record_id");
        sql.append(" from td_b_order_detail_park a ");
        sql.append(" where a.data_state =1");
        sql.append(" and a.order_id ? ");
        OrderDetailPark orderDetailPark = new OrderDetailPark().findFirst(sql.toString(), orderId);
        return orderDetailPark;
    }

    /**
     * 查询待支付的停车订单.<br/>
     * 步骤：
     * 1.查询待支付的订单
     * 1.调用艾润接口查询费用.<br/>
     * 3.更新订单费用.<br/>
     * 4.更新订单明细费用.<br/>
     * 5.插入订单流水表.
     *
     * @param carNum
     * @throws ParseException
     */
    public OrderVO queryParkOrderForNotPay(String orderId) throws ParseException {
        logger.info("---begin订单信息更新,orderId=" + orderId);
        OrderVO orderVO = new OrderVO();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        Map<String, String> resultmap = new HashMap<String, String>();
        //1.查询支付订单
        Order order = this.findOrderByOrderId(orderId);
        logger.info("通过车牌号查询到的支付订单信息结果＝" + JSONObject.toJSON(order));
        //2.调用查询费用接口
        if (order != null && StringKit.isNotBlank(order.getOrderId())) {
            resultmap = this.chosseBillQuery(order.getCarNumber(), order);
        }
        boolean orderUpdateFlg = false;
        int updateOrderDetailFlg = 0;
        //3.更新订单
        if (resultmap != null && resultmap.size() > 0) {
            Order updateOrder = new Order();
            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(resultmap.get("order_payed_fee")));
            updateOrder.setOrderNotPayFee(new BigDecimal(resultmap.get("order_not_pay_fee")));
            updateOrder.setOrderTotalFee(new BigDecimal(resultmap.get("order_total_fee")));
            updateOrder.setModfiyDate(new Date());
            /**更新订单表.*/
            orderUpdateFlg = updateOrder.update();
            logger.info("更新订单结果=" + (orderUpdateFlg == true ? "成功!" : "失败!"));
            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(),
                    resultmap.get("record_id"),
                    format.parse(resultmap.get("park_in_time")),
                    format.parse(resultmap.get("park_out_time")),
                    Long.valueOf(resultmap.get("parking_duration")),
                    new Date(),
                    order.getOrderId());
                logger.info("更新停车订单明细结果=" + (updateOrderDetailFlg > 0 ? "成功" : "失败"));
                if (updateOrderDetailFlg > 0) {
                    //封装返回数据
                    orderVO.setOrderId(order.getOrderId());
                }
                /**插入订单流水.*/
                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();

            }
        }

        logger.info("---end订单信息更新,结果=" + JSONObject.toJSON(orderVO));
        return orderVO;
    }

    /**
     * 查询费用艾润或者青岛路侧费用查询接口.<br/>
     *
     * @param carNum
     * @return
     */
    public Map<String, String> chosseBillQuery(String carNum, Order order) {
        OrderService orderService = Duang.duang(OrderService.class);
        IRainQueryService iRainQueryService = Duang.duang(IRainQueryService.class);
        Map<String, String> reultMap = new HashMap<String, String>();
        if (order != null && StringKit.isNotBlank(order.getOrderId())) {
            logger.info("查询费用来源=" + (order.getSourceType() == 2 ? "调用青岛路侧费用查询接口" : "调用艾润查询费用接口"));
            if ("1".equals(String.valueOf(order.getSourceType()))) {//道闸:调用艾润查询费用接口
                /**调用艾润查询费用接口.*/
                reultMap = iRainQueryService.billQuery(carNum, order.getParkId());
            } else if ("2".equals(String.valueOf(order.getSourceType()))
                && StringKit.isNotBlank(order.getOrderId())) {//调用青岛路侧查询费用接口
                /**查询停车记录id.*/
                OrderDetailPark OrderDetailPark = orderService.queryDetailParkByOrderId(order.getOrderId());
                if (OrderDetailPark != null && StringKit.isNotBlank(OrderDetailPark.getRecordId())) {
                    /**调用青岛路侧费用查询接口.*/
                    reultMap = iRainQueryService.queryBillRoadside(OrderDetailPark.getRecordId());
                }

            }
        }
        return reultMap;
    }

    /**
     * 通过车牌查询待核算支付单信息.<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,source_type,park_name");
        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(" and a.data_state=1");
        sql.append(" order by a.create_date DESC");

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

        return order;
    }

    /**
     * 通过车牌查询待核算支付单信息.<br/>
     *
     * @param
     */
    public Order findOrderByOrderId(String orderId) {
        //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,source_type,park_name");
        sql.append(" from td_b_order a");
        sql.append(" where a.order_state in(1,2,3)");
        sql.append(" and a.order_id=?");
        sql.append(" and a.data_state=1");
        Order order = new Order().findFirst(sql.toString(), orderId);
        return order;
    }

}