package com.ruoyi.web.controller.api;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.dto.CreateOrderDto;
import com.ruoyi.system.dto.CreateOrderRequest;
import com.ruoyi.system.model.TTicketOrder;
import com.ruoyi.system.query.AppletOrderListQuery;
import com.ruoyi.system.service.TAppUserService;
import com.ruoyi.system.service.TTicketOrderService;
import com.ruoyi.system.vo.AppletOrderListVO;
import com.ruoyi.system.vo.TTicketOrderVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Lazy;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.util.Base64;
import java.util.HashMap;

/**
 * 下单接口
 *
 * @author mitao
 * @since 2025-12-16
 */
@Slf4j
@RestController
@RequestMapping("/order")
@Api(tags = "订单模块")
@Validated
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class OrderController {

    private final TokenService tokenService;
    private final TAppUserService appUserService;
    private final TTicketOrderService tTicketOrderService;

    /**
     * 订单列表分页查询
     *
     * @param query 查询条件
     * @return 订单列表
     */
    @ApiOperation(value = "订单列表分页查询", response = AppletOrderListVO.class)
    @PostMapping("/list")
    public R<Page<TTicketOrderVo>> getOrderList(@RequestBody AppletOrderListQuery query) {
        Integer userId = tokenService.getLoginUserApplet().getUserId();
        Page<TTicketOrderVo> page = tTicketOrderService.getOrderList(query, userId);
        return R.ok(page);
    }


    /**
     * 下单
     *
     */
    @ApiOperation(value = "下单")
    @PostMapping("/addOrder")
    public R<Void> addOrder(@RequestBody CreateOrderDto request) throws Exception {
        Integer userId = tokenService.getLoginUserApplet().getUserId();
        boolean save = tTicketOrderService.addOrder(request, userId);
        if (!save) {
            return R.fail("下单失败");
        }
        return R.ok();
    }


    /**
     * 退单
     */
    @ApiOperation(value = "退单")
    @PostMapping("/refundOrder")
    public R<Void> refundOrder(@RequestParam Integer orderId) throws Exception {
        Integer userId = tokenService.getLoginUserApplet().getUserId();
        TTicketOrder order = tTicketOrderService.getById(orderId);
        if(order.getAppUserId().equals(userId)){
            boolean refund = tTicketOrderService.refundOrder(order);
            if(refund){
                return R.ok();
            }
        }
        return R.fail("退单失败");
    }


    /**
     * 验票通知
     */
    @ApiOperation(value = "验票通知")
    @PostMapping("/verifyTicket")
    public Object verifyTicket(HttpServletRequest request) throws Exception {
        // 取出requset的requestBody值
        String param = getParam(request);
        log.info("验票通知:{}", param);
        byte[] decode = Base64.getDecoder().decode(param);
        // 解码
        param = new String(decode, "UTF-8");

        JSONObject jsonObject = JSON.parseObject(param);
        JSONObject requestBody = jsonObject.getJSONObject("requestBody");
        String orderId = requestBody.getString("orderId");
        TTicketOrder order = tTicketOrderService.getOne(new LambdaQueryWrapper<TTicketOrder>().eq(TTicketOrder::getOrderNo, orderId));
        if(order!=null){
            JSONArray usedDetailIds = requestBody.getJSONArray("usedDetailIds");
            String visitPersons = order.getVisitPersons();
            JSONArray jsonArray = JSONArray.parseArray(visitPersons);
            JSONArray jsonArray1 = new JSONArray();
            if(usedDetailIds!=null){
                for (int i = 0; i < usedDetailIds.size(); i++) {
                    String ticketId = usedDetailIds.getString(i);
                    for (Object o : jsonArray) {
                        JSONObject jsonObject1 = JSONObject.parseObject(o.toString());
                        if(ticketId.equals(jsonObject1.getString("ticketId"))){
                            jsonObject1.put("status", 1);
                        }
                        jsonArray1.add(jsonObject1);
                    }
                }
            }
            order.setVisitPersons(jsonArray1.toJSONString());
            tTicketOrderService.updateById(order);
            HashMap<String, Object> map = new HashMap<>();
            HashMap<String, Object> response = new HashMap<>();
            response.put("res_code", "1000");
            response.put("res_msg", "操作成功");
            response.put("timestamp", System.currentTimeMillis());
            map.put("responseHead", response);
            map.put("responseBody", "");
            String s = JSON.toJSONString(map);
            String result = Base64.getEncoder().encodeToString(s.getBytes("UTF-8"));
            return result;
        }

        /**
         * {
         *     "responseHead": {
         *         "res_code": "1000",
         *         "res_msg": "操作成功",
         *         "timestamp": 1453801938
         *     },
         *     "responseBody": ""
         * }
         */
        return null;
    }


    public static void main(String[] args) throws UnsupportedEncodingException {
        HashMap<String, Object> fullRequestMap = new HashMap<>();
        fullRequestMap.put("requestHead", "headMap");
        fullRequestMap.put("requestBody", "encryptedBody");
        String fullRequestJson = JSON.toJSONString(fullRequestMap);
        String s = Base64.getEncoder().encodeToString(fullRequestJson.getBytes("UTF-8"));
        System.out.println(s);
        byte[] decode = Base64.getDecoder().decode(s);
        String s1 = new String(decode, "UTF-8");
        System.out.println(s1);
    }

    /**
     * 获取请求内容
     * @param request
     * @return
     * @throws IOException
     */
    private String getParam(HttpServletRequest request) throws IOException {
        // 读取参数
        InputStream inputStream;
        StringBuilder sb = new StringBuilder();
        inputStream = request.getInputStream();
        String s;
        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
        while ((s = in.readLine()) != null) {
            sb.append(s);
        }
        in.close();
        inputStream.close();
        return sb.toString();
    }
}