package com.stylefeng.guns.modular.system.controller.checkCar;

import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.stylefeng.guns.core.base.controller.BaseController;
import com.stylefeng.guns.core.base.tips.ErrorTip;
import com.stylefeng.guns.core.log.LogObjectHolder;
import com.stylefeng.guns.core.shiro.ShiroKit;
import org.springframework.data.redis.core.RedisTemplate;
import com.stylefeng.guns.modular.system.model.TAppUser;
import com.stylefeng.guns.modular.system.model.TOrderCheck;
import com.stylefeng.guns.modular.system.service.ITAppUserService;
import com.stylefeng.guns.modular.system.service.ITOrderCheckService;
import com.stylefeng.guns.modular.system.util.ResultUtil;
import com.stylefeng.guns.modular.system.controller.util.ExcelUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 代检车订单管理控制器
 *
 * @author fengshuonan
 * @Date 2025-07-28 23:31:10
 */
@Controller
@RequestMapping("/tOrderCheck")
public class TOrderCheckController extends BaseController {

    private static final Logger log = LoggerFactory.getLogger(TOrderCheckController.class);
    private String PREFIX = "/system/tOrderCheck/";

    @Autowired
    private ITOrderCheckService tOrderCheckService;

    @Autowired
    private ITAppUserService tAppUserService;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 跳转到代检车订单管理首页
     */
    @RequestMapping("")
    public String index() {
        return PREFIX + "tOrderCheck.html";
    }

    /**
     * 跳转到添加代检车订单管理
     */
    @RequestMapping("/tOrderCheck_add")
    public String tOrderCheckAdd(Model model) {
        List<TAppUser> tAppUsers = tAppUserService.selectList(new EntityWrapper<TAppUser>().eq("status", 1).eq("is_exception", 1));
        model.addAttribute("tAppUsers", tAppUsers);
        return PREFIX + "tOrderCheck_add.html";
    }

    /**
     * 跳转到修改代检车订单管理
     */
    @RequestMapping("/tOrderCheck_update/{tOrderCheckId}")
    public String tOrderCheckUpdate(@PathVariable Integer tOrderCheckId, Model model) {
        TOrderCheck tOrderCheck = tOrderCheckService.selectById(tOrderCheckId);
        model.addAttribute("item",tOrderCheck);
        LogObjectHolder.me().set(tOrderCheck);
        return PREFIX + "tOrderCheck_edit.html";
    }

    /**
     * 跳转到订单详情页面
     */
    @RequestMapping("/tOrderCheck_detail/{tOrderCheckId}")
    public String tOrderCheckDetail(@PathVariable Integer tOrderCheckId, Model model) {
        TOrderCheck orderInfo = tOrderCheckService.getOrderInfo(tOrderCheckId);
        if (orderInfo == null) {
            // 如果订单不存在，返回错误页面或重定向
            return "redirect:" + PREFIX + "tOrderCheck.html";
        }

        // 格式化所有需要的时间字段并设置到orderInfo对象中
        java.text.SimpleDateFormat dateFormat = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        if (orderInfo.getCreateTime() != null) {
            orderInfo.setCreateTimeFormat(dateFormat.format(orderInfo.getCreateTime()));
        }
        if (orderInfo.getReservationTime() != null) {
            orderInfo.setReservationTimeFormat(dateFormat.format(orderInfo.getReservationTime()));
        }
        if (orderInfo.getDispatchTime() != null) {
            orderInfo.setDispatchTimeFormat(dateFormat.format(orderInfo.getDispatchTime()));
        }
        if (orderInfo.getOrderTakingTime() != null) {
            orderInfo.setOrderTakingTimeFormat(dateFormat.format(orderInfo.getOrderTakingTime()));
        }
        if (orderInfo.getArrivalTimeAtTheAppointmentPoint() != null) {
            orderInfo.setArrivalTimeAtTheAppointmentPointFormat(dateFormat.format(orderInfo.getArrivalTimeAtTheAppointmentPoint()));
        }
        if (orderInfo.getStartTime() != null) {
            orderInfo.setStartTimeFormat(dateFormat.format(orderInfo.getStartTime()));
        }
        if (orderInfo.getEndTime() != null) {
            orderInfo.setEndTimeFormat(dateFormat.format(orderInfo.getEndTime()));
        }
        if (orderInfo.getGoTime() != null) {
            orderInfo.setGoTimeFormat(dateFormat.format(orderInfo.getGoTime()));
        }
        if (orderInfo.getSuccessTime() != null) {
            orderInfo.setSuccessTimeFormat(dateFormat.format(orderInfo.getSuccessTime()));
        }
        if (orderInfo.getPayTime() != null) {
            orderInfo.setPayTimeFormat(dateFormat.format(orderInfo.getPayTime()));
        }
        if (orderInfo.getCheckPayTime() != null) {
            orderInfo.setCheckPayTimeFormat(dateFormat.format(orderInfo.getCheckPayTime()));
        }
        if (orderInfo.getCommentTime() != null) {
            orderInfo.setCommentTimeFormat(dateFormat.format(orderInfo.getCommentTime()));
        }

        // 处理车检图片
        if (orderInfo.getCheckImg() != null && !orderInfo.getCheckImg().isEmpty()) {
            List<String> checkImgList = Arrays.stream(orderInfo.getCheckImg().split(","))
                    .map(String::trim)
                    .filter(s -> !s.isEmpty())
                    .collect(Collectors.toList());
            orderInfo.setCheckImgList(checkImgList);
        } else {
            orderInfo.setCheckImgList(Collections.emptyList());
        }


        // 将包含了所有格式化时间字段的orderInfo对象转换为JSON字符串
        String orderInfoStr = JSON.toJSONString(orderInfo);
        model.addAttribute("orderInfoStr", orderInfoStr);
        model.addAttribute("orderInfo", orderInfo);
        
        return PREFIX + "tOrderCheck_detail.html";
    }

    /**
     * 获取代检车订单管理列表
     */
    @RequestMapping(value = "/list")
    @ResponseBody
    public Object list(String createTime,
                       String code,
                       Integer source,
                       String userName,
                       String userPhone,
                       Integer state,
                       String driverName) {
        return super.packForBT(tOrderCheckService.getOrderCheckList(createTime, code, source, userName, userPhone, state, driverName));
    }

    /**
     * 删除代检车订单管理
     */
    @RequestMapping(value = "/delete")
    @ResponseBody
    public Object delete(@RequestParam Integer tOrderCheckId) {
        TOrderCheck tOrderCheck = new TOrderCheck();
        tOrderCheck.setId(tOrderCheckId);
        tOrderCheck.setStatus(3); // 设置状态为已删除
        tOrderCheckService.updateById(tOrderCheck);
        return SUCCESS_TIP;
    }

    /**
     * 修改代检车订单管理
     */
    @RequestMapping(value = "/update")
    @ResponseBody
    public Object update(TOrderCheck tOrderCheck) {
        tOrderCheckService.updateById(tOrderCheck);
        return SUCCESS_TIP;
    }

    /**
     * 代检车订单管理详情
     */
    @RequestMapping(value = "/detail/{tOrderCheckId}")
    @ResponseBody
    public Object detail(@PathVariable("tOrderCheckId") Integer tOrderCheckId) {
        return tOrderCheckService.selectById(tOrderCheckId);
    }

    /**
     * 关闭订单
     */
    @RequestMapping(value = "/cancel")
    @ResponseBody
    public Object cancel(@RequestParam Integer tOrderCheckId) {
        try {
            tOrderCheckService.cancel(tOrderCheckId);
            return SUCCESS_TIP;
        } catch (Exception e) {
            log.error("取消订单异常: ", e);
            return new ErrorTip(ResultUtil.ERROR, "服务器开小差啦");
        }
    }
    /**
     * 跳转到派单页面
     * 
     * @param tOrderCheckId 订单ID
     * @param type 派单类型：1=派单，2=改派
     * @param model 视图模型
     * @return 派单页面路径
     */
    @RequestMapping("/tOrderCheck_dispatch/{tOrderCheckId}/{type}")
    public String tOrderCheckDispatch(@PathVariable Integer tOrderCheckId, 
                                    @PathVariable Integer type, 
                                    Model model) {
        try {
            // 获取订单和用户信息
            TOrderCheck orderInfo = tOrderCheckService.getOrderInfo(tOrderCheckId);
            orderInfo.setReservationTimeFormat(DateUtil.format(orderInfo.getReservationTime(), DatePattern.NORM_DATETIME_PATTERN));
            model.addAttribute("orderId", tOrderCheckId);
            model.addAttribute("dispatchType", type);
            model.addAttribute("orderInfoData", orderInfo);
            return PREFIX + "tOrderCheck_dispatch.html";
        } catch (Exception e) {
            model.addAttribute("errorMsg", e.getMessage());
            return PREFIX + "tOrderCheck_dispatch.html";
        }
    }
    /**
     * 跳转到批量派单页面
     *
     * @param orderIds 订单ids
     * @param model 视图模型
     * @return 派单页面路径
     */
    @RequestMapping("/tOrderCheck_dispatchBatch")
    public String tOrderCheckDispatchBatch(String orderIds, Model model) {
        // 解析订单ID数组
        String[] orderIdArray = orderIds.split(",");
        List<Integer> orderIdList = Arrays.asList(orderIdArray).stream().map(Integer::valueOf).collect(Collectors.toList());

        // 查询选中的订单信息
        List<TOrderCheck> orderList = tOrderCheckService.getOrdersByIds(orderIdList);

        // 验证订单状态（确保都是可派单状态）
        List<TOrderCheck> validOrders = orderList.stream()
                .filter(item -> item.getState().equals(100))
                .peek(item->{
            item.setCreateTimeFormat(DateUtil.format(item.getCreateTime(), DatePattern.NORM_DATETIME_FORMAT));
            item.setReservationTimeFormat(DateUtil.format(item.getReservationTime(), DatePattern.NORM_DATETIME_FORMAT));
        }).collect(Collectors.toList());

        // 将订单信息传递给前端页面
        model.addAttribute("orderList", validOrders);
        model.addAttribute("orderIds", orderIds);
        return PREFIX + "tOrderCheck_dispatchBatch.html";
    }
    /**
     * 获取可派单司机分页列表（Ajax接口）
     */
    @RequestMapping(value = "/dispatchData")
    @ResponseBody
    public Object getDispatchDriverList(@RequestParam(required = false) Integer orderId,
                                        @RequestParam Integer dispatchType,
                                        @RequestParam(defaultValue = "") String keyword) {
        try {
            return super.packForBT(tOrderCheckService.getDispatchDriverList(orderId, dispatchType, keyword));
        } catch (Exception e) {
            log.error("派单操作异常: ", e);
            return new ErrorTip(ResultUtil.ERROR, "服务器开小差啦");
        }
    }

    /**
     * 执行派单/改派操作
     */
    @RequestMapping(value = "/executeDispatch")
    @ResponseBody
    public Object executeDispatch(@RequestParam Integer orderId,
                                @RequestParam Integer driverId,
                                @RequestParam Integer dispatchType) {
        try {
            tOrderCheckService.executeDispatch(orderId, driverId, dispatchType);
            return SUCCESS_TIP;
        } catch (Exception e) {
            log.error("派单操作异常: ", e);
            return new ErrorTip(ResultUtil.ERROR, "服务器开小差啦");
        }
    }

    /**
     * 执行批量派单操作
     */
    @RequestMapping(value = "/executeBatchDispatch")
    @ResponseBody
    public Object executeBatchDispatch(@RequestParam String orderIds,
                                     @RequestParam String driverIds) {
        try {
            // 解析订单ID数组
            List<Integer> orderIdList = Arrays.stream(orderIds.split(","))
                    .map(String::trim)
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());
            
            // 解析司机ID数组
            List<Integer> driverIdList = Arrays.stream(driverIds.split(","))
                    .map(String::trim)
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());
            
            // 验证订单数量和司机数量是否匹配
            if (orderIdList.size() != driverIdList.size()) {
                return new ErrorTip(ResultUtil.ERROR, "订单数量与司机数量不匹配");
            }
            
            // 执行批量派单
            tOrderCheckService.executeBatchDispatch(orderIdList, driverIdList);
            return SUCCESS_TIP;
        } catch (Exception e) {
            log.error("批量派单操作异常: ", e);
            return new ErrorTip(ResultUtil.ERROR, e.getMessage());
        }
    }

    /**
     * 新建订单
     */
    @RequestMapping(value = "/add")
    @ResponseBody
    public Object add(@RequestParam Integer userId,
                      @RequestParam String startAddress,
                      @RequestParam String endAddress,
                      @RequestParam String reservationTime) {
        try {
            tOrderCheckService.addOrder(userId, startAddress, endAddress, reservationTime);
            return SUCCESS_TIP;
        } catch (Exception e) {
            log.error("新建订单失败: {}", e.getMessage(), e);
            return new ErrorTip(ResultUtil.ERROR, "服务器开小差啦");
        }
    }

    /**
     * 导出车检订单列表
     */
    @RequestMapping(value = "/export")
    @ResponseBody
    public void export(HttpServletResponse response,
                      String createTime,
                      String code,
                      Integer source,
                      String userName,
                      String userPhone,
                      Integer state,
                      String driverName) throws IOException {
        try {
            // 获取导出数据
            List<TOrderCheck> exportData = tOrderCheckService.exportOrderCheckList(createTime, code, source, userName, userPhone, state, driverName);
            
            // 定义Excel表头
            String[] headers = {"下单时间", "订单编号", "订单来源", "预约时间", "下单用户昵称", 
                               "下单用户手机", "取车地", "还车地", "接单司机", "司机电话", "状态"};
            
            // 枚举值映射
            Map<Integer, String> stateMap = new HashMap<>();
            stateMap.put(100, "待派单");
            stateMap.put(101, "待接单");
            stateMap.put(102, "服务中");
            stateMap.put(104, "服务中");
            stateMap.put(105, "服务中");
            stateMap.put(106, "服务中");
            stateMap.put(107, "服务中");
            stateMap.put(108, "服务中");
            stateMap.put(109, "已完成");
            stateMap.put(110, "已完成");
            stateMap.put(111, "取消");
            
            Map<Integer, String> sourceMap = new HashMap<>();
            sourceMap.put(1, "小程序");
            sourceMap.put(2, "管理后台");
            
            // 时间格式化器
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            
            // 构建数据数组
            String[][] values = new String[exportData.size()][headers.length];
            for (int i = 0; i < exportData.size(); i++) {
                TOrderCheck order = exportData.get(i);
                values[i][0] = order.getCreateTime() != null ? dateFormat.format(order.getCreateTime()) : "";
                values[i][1] = order.getCode() != null ? order.getCode() : "";
                values[i][2] = sourceMap.getOrDefault(order.getSource(), "未知");
                values[i][3] = order.getReservationTime() != null ? dateFormat.format(order.getReservationTime()) : "";
                values[i][4] = order.getUserName() != null ? order.getUserName() : "";
                values[i][5] = order.getUserPhone() != null ? order.getUserPhone() : "";
                values[i][6] = order.getStartAddress() != null ? order.getStartAddress() : "";
                values[i][7] = order.getEndAddress() != null ? order.getEndAddress() : "";
                values[i][8] = order.getDriverName() != null ? order.getDriverName() : "";
                values[i][9] = order.getDriverPhone() != null ? order.getDriverPhone() : "";
                values[i][10] = stateMap.getOrDefault(order.getState(), "未知状态");
            }
            
            // 生成Excel文件名
            String fileName = "车检订单列表_" + new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()) + ".xls";
            
            // 生成Excel
            HSSFWorkbook workbook = ExcelUtil.getHSSFWorkbook("车检订单列表", headers, values, null);
            
            // 设置响应头
            ExcelUtil.setResponseHeader(response, URLEncoder.encode(fileName, "UTF-8"));
            
            // 输出文件
            workbook.write(response.getOutputStream());
            response.getOutputStream().flush();
            response.getOutputStream().close();
            
        } catch (Exception e) {
            log.error("导出车检订单列表失败: {}", e.getMessage(), e);
            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            response.getWriter().write("导出失败: " + e.getMessage());
        }
    }

    /**
     * 检查代检车新订单通知
     */
    @RequestMapping(value = "/checkNewOrderNotification")
    @ResponseBody
    public Object checkNewOrderNotification() {
        try {
            // 获取当前用户信息
            Integer roleType = ShiroKit.getUser().getRoleType();
            Integer objectId = ShiroKit.getUser().getObjectId();
            
            Map<String, Object> result = new HashMap<>();
            List<String> orderIds = new ArrayList<>();
            
            String redisKey;
            if (roleType == 1) {
                // 平台用户 - 查看所有新订单
                redisKey = "newCheckCarOrder:platform";
            } else {
                // 分公司用户 - 只查看本分公司的新订单
                redisKey = "newCheckCarOrder:branch:" + objectId;
            }
            
            // 从Redis List获取新订单ID列表
            List<String> orderList = redisTemplate.opsForList().range(redisKey, 0, -1);
            if (orderList != null && !orderList.isEmpty()) {
                orderIds = orderList;
            }
            
            boolean hasNewOrder = !orderIds.isEmpty();
            int orderCount = orderIds.size();
            
            // 构建返回结果
            result.put("hasNewOrder", hasNewOrder);
            result.put("orderCount", orderCount);
            result.put("orderIds", orderIds);
            result.put("currentTime", DateUtil.format(new Date(), DatePattern.NORM_DATETIME_FORMAT));
            
            // 如果有新订单，清空Redis中的记录（表示已经通知过了）
            if (hasNewOrder) {
                redisTemplate.delete(redisKey);
            }
            
            return result;
            
        } catch (Exception e) {
            log.error("检查代检车新订单通知失败: {}", e.getMessage(), e);
            Map<String, Object> errorResult = new HashMap<>();
            errorResult.put("hasNewOrder", false);
            errorResult.put("orderCount", 0);
            errorResult.put("orderIds", new ArrayList<>());
            errorResult.put("error", "检查通知失败");
            return errorResult;
        }
    }
}