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 org.beetl.sql.core.kit.StringKit;

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.ErrorType;
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.DateUtil;
import com.rnt.utils.SequenceUtil;
import com.rnt.vo.OrderVO;

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;
    }
    
    /**
     * 通过订单好
     * @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 carNum) throws ParseException {
        logger.info("---begin订单信息更新,carNum=" + carNum);
        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.findOrderByCarNum(carNum);
        logger.info("通过车牌号查询到的支付订单信息结果＝"+JSONObject.toJSON(order));
        //2.调用查询费用接口
        if (order != null && StringKit.isNotBlank(order.getOrderId())) {
        	resultmap = this.chosseBillQuery(carNum,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());
                    orderVO.setParkId(order.getParkId());
                    orderVO.setParkName(resultmap.get("park_name"));
                    orderVO.setParkAddress(resultmap.get("park_address"));
                    orderVO.setCarNumber(order.getCarNumber());
                    orderVO.setOrderPayedFee(new BigDecimal(resultmap.get("order_payed_fee")));
                    orderVO.setOrderNotPayFee(new BigDecimal(resultmap.get("order_not_pay_fee")));
                    orderVO.setOrderTotalFee(new BigDecimal(resultmap.get("order_total_fee")));
                    orderVO.setOrderTitle("待付费用");
                    orderVO.setParkInTime(format.parse(resultmap.get("park_in_time")));
                    orderVO.setParkOutTime(format.parse(resultmap.get("park_out_time")));
                    orderVO.setParkingDuration(DateUtil.secondToTime(Long.valueOf(resultmap.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();

            } 
        }
    
        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())) {
             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");
        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;
    }


}