package com.chuanghai.smartschool.tuitionpayment.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.chuanghai.smartschool.tuitionpayment.anno.AdminLoginCheck;
import com.chuanghai.smartschool.tuitionpayment.common.exception.BizCodeEnume;
import com.chuanghai.smartschool.tuitionpayment.common.exception.RRException;
import com.chuanghai.smartschool.tuitionpayment.common.utils.CommonResult;
import com.chuanghai.smartschool.tuitionpayment.common.utils.PageParam;
import com.chuanghai.smartschool.tuitionpayment.common.utils.PageUtils;
import com.chuanghai.smartschool.tuitionpayment.entity.PayOrderEntity;
import com.chuanghai.smartschool.tuitionpayment.entity.PayableInfoEntity;
import com.chuanghai.smartschool.tuitionpayment.entity.PayableInfoWaterEntity;
import com.chuanghai.smartschool.tuitionpayment.service.PayOrderService;
import com.chuanghai.smartschool.tuitionpayment.service.PayableInfoService;
import com.chuanghai.smartschool.tuitionpayment.service.PayableInfoWaterService;
import com.chuanghai.smartschool.tuitionpayment.to.OrderReceiveTO;
import com.chuanghai.smartschool.tuitionpayment.to.PayOrderQueryTO;
import com.chuanghai.smartschool.tuitionpayment.vo.*;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 缴费订单
 *
 * @author codingliang
 * @email codingliang@gmail.com
 * @date 2021-08-12 15:52:41
 */
@RestController
@RequestMapping("tuitionpayment/payorder")
public class PayOrderController {
    @Autowired
    private PayOrderService payOrderService;
    @Autowired
    private PayableInfoService payableInfoService;
    @Autowired
    private PayableInfoWaterService payableInfoWaterService;


    @GetMapping("ss")
    public void ss(String order){
        payOrderService.getByOrderNo(order);
    }

    /**
     * 创建支付订单
     *
     * @param cardNumber 当前登录用户cardNumber
     * @return
     */
    @PostMapping("/{studentNo}/create")
    public CommonResult<List<CreateOrderResultVO>> createPayOrder(@RequestHeader("card_number") String cardNumber,
                                                                  @RequestBody JSONObject jsonObject) {

        PayOrderReceiveVO payOrderReceiveVO = JSONObject.toJavaObject(jsonObject, PayOrderReceiveVO.class);


        List<CreateOrderResultVO> resultVOList = payOrderService.createOrder(cardNumber, payOrderReceiveVO);

        return CommonResult.ok().setResult(resultVOList);
    }

    /**
     * 用于接收创建支付订单的参数便于后续支付明细分流
     *
     * @param cardNumber 当前登录用户cardNumber
     * @param jsonObject 支付参数的结构体
     * @return
     */
    @PostMapping("/{studentNo}/receiveOrder")
    public CommonResult<T> receiveOrder(@RequestHeader("card_number") String cardNumber,
                                        @RequestBody JSONObject jsonObject) {
        PayOrderReceiveVO payOrderReceiveVO = JSONObject.toJavaObject(jsonObject, PayOrderReceiveVO.class);
        List<OrderReceiveTO> orderReceiveTOS = payOrderService.receiveOrder(cardNumber, payOrderReceiveVO);
        return CommonResult.ok().setResult(orderReceiveTOS);
    }

    /**
     * 订单列表【当前用户】
     *
     * @param cardNumber 当前登录用户cardNumber
     * @param status     订单状态  1 失败订单   2 成功订单
     * @param pageParam  分页参数
     * @return
     */
    @GetMapping("currentUserList")
    public CommonResult<PageUtils<PayOrderEntity>> currentUserList(@RequestHeader("card_number") String cardNumber,
                                                                   @RequestParam("status") String status,
                                                                   PageParam pageParam) {
        PageUtils page = payOrderService.queryPage(pageParam, cardNumber, status);

        return CommonResult.ok().setResult(page);
    }

    /**
     * 查询订单状态【用户端】
     * <p>
     *
     * @param orderNo 订单号
     * @return
     */
    @GetMapping("{orderNo}/orderStatu")
    public CommonResult<OrderStatusVO> queryOrderStatus( @PathVariable("orderNo") String orderNo) {
        OrderStatusVO orderStatusVO = payOrderService.queryOrderStatus(orderNo);
        return CommonResult.ok().setResult(orderStatusVO);
    }

    /**
     * 订单列表【管理端】
     * <p>
     * @param adminToken 管理员token
     * @param queryTO   查询条件
     * @param pageParam 分页参数
     * @return
     * @apiNote 0.1.0 新增按照支付方式查询
     */
    @AdminLoginCheck
    @GetMapping("/list")
    public CommonResult<PayOrderListVO> list(@RequestHeader("admin_token") String adminToken,
                                             PayOrderQueryTO queryTO,
                                             PageParam pageParam) {

        String flag = queryTO.getFlag();
        String createDateStr = queryTO.getCreateDateStr();
        String payDateStr = queryTO.getPayDateStr();
        if (!("1".equals(flag) || "2".equals(flag) || "3".equals(flag))) {
            throw new RRException(BizCodeEnume.PARAMETER_ERROR, "flag只允许传1、2、3");
        }
        if (!"1".equals(flag)) {
            if (!(StringUtils.hasText(payDateStr) || StringUtils.hasText(createDateStr))) {
                throw new RRException(BizCodeEnume.PARAMETER_ERROR, "查询时间不能为空");
            }
        }
        PageUtils page = payOrderService.queryPage(queryTO, pageParam);

        String amountCount = payOrderService.queryPayOrderAmount(queryTO);

        PayOrderListVO payOrderListVO = new PayOrderListVO();
        BigDecimal total = new BigDecimal(amountCount.split("-")[0]).setScale(2, RoundingMode.HALF_UP);
        BigDecimal payOrderLoan = new BigDecimal(amountCount.split("-")[2]).setScale(2, RoundingMode.HALF_UP);
        payOrderListVO.setTotal(total);
        payOrderListVO.setPage(page);
        payOrderListVO.setRecordsNum(Integer.parseInt(amountCount.split("-")[1]));
        payOrderListVO.setPayOrderLoan(payOrderLoan);
        payOrderListVO.setOrderAllAmount(total.add(payOrderLoan));
        return CommonResult.ok().setResult(payOrderListVO);
    }


    /**
     * 查询所有项目的记录
     *
     * @return
     */
    @GetMapping("/queryAllAmount")
    public CommonResult<T> queryAllItemNameAmount() {
        QueryWrapper<PayOrderEntity> wrapper = new QueryWrapper<>();
        wrapper.eq("status", "2");
        List<PayOrderEntity> orderlist = payOrderService.list(wrapper);
        BigDecimal totalAmount = BigDecimal.ZERO;
        if (orderlist.size() > 0) {
            for (int i = 0; i < orderlist.size(); i++) {
                totalAmount = totalAmount.add(orderlist.get(i).getNowPayAmount()).setScale(2, BigDecimal.ROUND_HALF_UP);
            }
        }
        Integer totalCount = orderlist.size();
        return CommonResult.ok().setResult(totalCount + "-" + totalAmount);
    }

    /**
     * 查询相应项目的所有订单数及金额
     *
     * @param itemName 缴费项目
     * @return
     */
    @GetMapping("/queryAmount")
    public CommonResult<T> queryAmountByItemName(@RequestParam("itemName") String itemName) {
        String s = payOrderService.queryAmount(itemName);
        return CommonResult.ok().setResult(s);
    }


    /**
     * 查询订单状态【管理端】
     *
     * @param orderNo 订单号
     * @return
     */
    @GetMapping("queryOrderStatu")
    public CommonResult<OrderStatusVO> queryOrderStatusByAdmin( @RequestParam String orderNo) {
        OrderStatusVO orderStatusVO = payOrderService.queryOrderStatus(orderNo);
        return CommonResult.ok().setResult(orderStatusVO);
    }


    /**
     * 下载缴费的学生名单
     * <p>
     *
     * @param response
     * @apiNote 0.1.0新增按照支付方式下载字段
     */
    @RequestMapping("downloadResult")
    public void downloadResult(PayOrderQueryTO queryTO,
                               HttpServletResponse response) throws IOException {
        List<String> downIDs = new ArrayList<>();
        String downIds = queryTO.getDownIds();
        if (downIds != null && !downIds.equals("")) {
            String[] split = downIds.split("/");
            for (int m = 0; m < split.length; m++) {
                downIDs.add(split[m]);
            }
        }

        try {
            String flag = queryTO.getFlag();
            String createDateStr = queryTO.getCreateDateStr();
            String payDateStr = queryTO.getPayDateStr();
            if (!("1".equals(flag) || "2".equals(flag) || "3".equals(flag))) {
                throw new RRException(BizCodeEnume.PARAMETER_ERROR, "flag只允许传1、2、3");
            }
            if (!"1".equals(flag)) {
                if (!(StringUtils.hasText(payDateStr) || StringUtils.hasText(createDateStr))) {
                    throw new RRException(BizCodeEnume.PARAMETER_ERROR, "查询时间不能为空");
                }
            }
            payOrderService.downloadResult(response, queryTO, downIDs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 下载缴费名单的txt
     *
     * @param queryTO  查询参数
     * @param response
     * @throws IOException
     */
    @RequestMapping("exportOrderTxt")
    public void exportTxt(PayOrderQueryTO queryTO,
                          HttpServletResponse response) throws IOException {
        try {
            List<String> downIDs = new ArrayList<>();
            String downIds = queryTO.getDownIds();
            if (downIds != null && !downIds.equals("")) {
                String[] split = downIds.split("/");
                for (int m = 0; m < split.length; m++) {
                    downIDs.add(split[m]);
                }
            }
            if (!queryTO.getItemName().equals("学杂费")) {
                throw new RRException(BizCodeEnume.PAY_ITEM_NOT_SUPPORT, "该项目不支持导出TXT文件");
            }
            String flag = queryTO.getFlag();
            String createDateStr = queryTO.getCreateDateStr();
            String payDateStr = queryTO.getPayDateStr();
            if (!("1".equals(flag) || "2".equals(flag) || "3".equals(flag))) {
                throw new RRException(BizCodeEnume.PARAMETER_ERROR, "flag只允许传1、2、3");
            }
            if (!"1".equals(flag)) {
                if (!(StringUtils.hasText(payDateStr) || StringUtils.hasText(createDateStr))) {
                    throw new RRException(BizCodeEnume.PARAMETER_ERROR, "查询时间不能为空");
                }
            }
            payOrderService.exportOrderTxt(response, queryTO, downIDs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 下载缴费名单的txt点击开始计时十五分钟，导出十五分钟内的数据
     *
     * @param response
     * @param type   today 当天  quarter 十五分钟
     *
     * @throws IOException
     */
    @RequestMapping("exportOrderTxtQuarter")
    public void exportOrderTxtQuarter( HttpServletResponse response, String type ) throws IOException {
        try {
            payOrderService.exportOrderTxtQuarter(response, type);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 通过订单编号查询缴费订单详情  查看订单详情 【用户端】
     *
     * @param orderNo 订单编号
     * @return
     */
    @GetMapping("/queryOrderDetail")
    public CommonResult<PayOrderEntity> queryPayOrderDetail(@RequestParam("orderNo") String orderNo) {
        QueryWrapper<PayOrderEntity> wrapper = new QueryWrapper<>();
        wrapper.eq(StringUtils.hasText(orderNo), "order_no", orderNo);
        PayOrderEntity one = payOrderService.getOne(wrapper);
        return CommonResult.ok().setResult(one);
    }


    /**
     * 查看全部订单的详情
     *
     * @param cardNumber
     * @param pageParam
     * @param status     订单状态
     * @return
     */
    @GetMapping("/queryAllOrder")
    public CommonResult<PageUtils<PayOrderEntity>> queryAllOrderByParent(@RequestHeader("card_number") String cardNumber,
                                                                         PageParam pageParam,
                                                                         @RequestParam("status") String status,
                                                                         String itemName, String payYear) {

        PageUtils page = payOrderService.queryAllOrder(cardNumber, pageParam, status, itemName, payYear);
        return CommonResult.ok().setResult(page);
    }


    @GetMapping("/updateOrderDetail")
    public void updateOrderDetail(String orderNo) {
        QueryWrapper<PayOrderEntity> wrapper = new QueryWrapper<>();
        wrapper.eq("order_no", orderNo);
        PayOrderEntity payOrderEntity = this.payOrderService.getOne(wrapper);
        String payItem = payOrderEntity.getPayItem();
        BigDecimal notPayAmount = BigDecimal.ZERO;
        BigDecimal payAmount = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
        if (payItem.equals("水费缴纳")) {
            QueryWrapper<PayableInfoWaterEntity> wrapper1 = new QueryWrapper<>();
            wrapper1.eq("student_no", payOrderEntity.getPayForIdentify())
                    .eq("student_name", payOrderEntity.getStudentName())
                    .eq("pay_month", payOrderEntity.getPayYear());
            PayableInfoWaterEntity payableInfoWaterEntity = payableInfoWaterService.getOne(wrapper1);
            payOrderEntity.setRealPayAmount(payableInfoWaterEntity.getRealPayAmount());
            payOrderEntity.setPayDetail(payableInfoWaterEntity.getPayAmountDetail());
            payOrderEntity.setNowPayAmount(payableInfoWaterEntity.getRealPayAmount());
        } else {
            QueryWrapper<PayableInfoEntity> wrapper1 = new QueryWrapper<>();
            wrapper1.eq("student_no", payOrderEntity.getPayForIdentify())
                    .eq("student_name", payOrderEntity.getStudentName())
                    .eq("years", payOrderEntity.getPayYear());
            PayableInfoEntity payableInfoEntity = payableInfoService.getOne(wrapper1);
            if (payableInfoEntity == null) {
                throw new RRException(BizCodeEnume.DATA_IS_EXIST, "暂无该缴费订单。");
            }

            if (!payableInfoEntity.getNotPayDetail().isEmpty()) {
                payOrderEntity.setNotPayDetail(payableInfoEntity.getNotPayDetail());
                String[] notPayDetail = payableInfoEntity.getNotPayDetail().split("/");

                for (int i = 0; i < notPayDetail.length; i++) {
                    notPayAmount = notPayAmount.add(new BigDecimal(notPayDetail[i].split(":")[1]));
                }
            }
            if (!payableInfoEntity.getPayDetail().isEmpty()) {
                payOrderEntity.setPayDetail(payableInfoEntity.getPayDetail());
                String[] payDetail = payableInfoEntity.getPayDetail().split("/");
                for (int i = 0; i < payDetail.length; i++) {
                    payAmount = payAmount.add(new BigDecimal(payDetail[i].split(":")[1]));
                }
            }

        }
        payOrderEntity.setRealPayAmount(payAmount.setScale(2, RoundingMode.HALF_UP));
    }

    /**
     * 根据订单编号查询步骤详情
     *
     * @param orderNo
     * @param secondOrderNo
     * @return
     */
    @GetMapping("showStepDetail")
    public CommonResult<List<OrderViewVO>> showStepDetail(String orderNo, String secondOrderNo) {
        List<OrderViewVO> orderViewVOList = new ArrayList<>();
        QueryWrapper<PayOrderEntity> wrapper = new QueryWrapper<>();
        wrapper.in("order_no", orderNo, secondOrderNo);
        List<PayOrderEntity> orderList = payOrderService.list(wrapper);
        orderList.forEach(order -> {
            OrderViewVO orderViewVO = new OrderViewVO();
            orderViewVO.setItemName(order.getPayItem());
            orderViewVO.setPayDetail(order.getPayDetail());
            orderViewVO.setPayDetailAmount(order.getNowPayAmount());
            orderViewVO.setOrderNo(order.getOrderNo());
            orderViewVO.setPayMethod(order.getPayMethod());
            orderViewVO.setStatus(order.getStatus());
            orderViewVOList.add(orderViewVO);
        });
        return CommonResult.ok().setResult(orderViewVOList);
    }

    /**
     * 根据cardNumber 查询用户所交的项目及时间
     *
     * @param cardNumber
     * @param
     * @param status
     * @return
     */
    @GetMapping("queryOrderItem")
    public CommonResult<OrderQueryVO> queryOrderItem(@RequestHeader("card_number") String cardNumber,
                                                     @RequestParam("status") String status) {

        List<OrderQueryVO> orderQueryVOList = new ArrayList<>();
        QueryWrapper<PayOrderEntity> wrapper = new QueryWrapper<>();
        wrapper.eq(StringUtils.hasText(status), "status", status)
                .eq(StringUtils.hasText(cardNumber), "payer_identify", cardNumber);
        List<PayOrderEntity> orderList = payOrderService.list(wrapper);
        orderList.forEach(order -> {
            OrderQueryVO orderQueryVO = new OrderQueryVO();
            orderQueryVO.setText(order.getPayItem());
            orderQueryVO.setValue(order.getPayItem());
            List<YearVo> lists = queryYearByItem(cardNumber, status, order.getPayItem());
            orderQueryVO.setChildren(lists);
            orderQueryVOList.add(orderQueryVO);
        });
        List uniqueStr = orderQueryVOList.stream().distinct().collect(Collectors.toList());
        return CommonResult.ok().setResult(uniqueStr);
    }


    /**
     * 根据项目查询订单年度
     *
     * @param cardNumber
     * @param itemName
     * @param status
     * @return
     */
    @GetMapping("queryYearByItem")
    public List<YearVo> queryYearByItem(String cardNumber,
                                        String status,
                                        @RequestParam("itemName") String itemName) {
        QueryWrapper<PayOrderEntity> wrapper = new QueryWrapper<>();
        List<YearVo> yearList = new ArrayList<>();
        wrapper.eq(StringUtils.hasText(itemName), "pay_item", itemName)
                .eq("status", status)
                .eq(StringUtils.hasText(cardNumber), "payer_identify", cardNumber);
        List<PayOrderEntity> orderList = payOrderService.list(wrapper);
        orderList.forEach(order -> {
            YearVo yearVo = new YearVo();
            yearVo.setText(order.getPayYear());
            yearVo.setValue(order.getPayYear());
            yearList.add(yearVo);

        });
          List uniqueStr = yearList.stream().distinct().collect(Collectors.toList());

        return uniqueStr;
    }


    /**
     * 通过缴费项目及缴费状态查询缴费年度信息
     * @param itemName
     * @param status
     * @return
     */
    @GetMapping("queryOrderYearByItem")
    public CommonResult<List<String>> queryYearByItem(String itemName, String status){
        List<String> yearList = new ArrayList<>();
        QueryWrapper<PayOrderEntity> orderWapper = new QueryWrapper<>();
        orderWapper.eq("pay_item", itemName)
                .eq("status", status);
        List<PayOrderEntity> orderList = payOrderService.list(orderWapper);
        if (orderList.size() > 0) {
            orderList.forEach(order->{
                yearList.add(order.getPayYear());
            });
        }
        List uniqueStr = yearList.stream().distinct().collect(Collectors.toList());
        return CommonResult.ok().setResult(uniqueStr);
    }
}