package com.ruoyi.api.third.controller;

import java.util.*;
import java.util.stream.Collectors;

import cn.hutool.json.JSONUtil;
import com.ruoyi.cwgl.domain.DispatchOrder;
import com.ruoyi.tms.mapper.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.api.third.util.ApiAuthUtil;
import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.tms.domain.*;
import com.ruoyi.tms.domain.vo.*;
import com.ruoyi.tms.service.ITmsDispatchOrderService;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * AI调度专用第三方接口 (无需权限, 使用appId/secret认证)
 *
 * @author ruoyi
 * @date 2026-03-06
 */
@RestController
@RequestMapping("/api/third/aiDispatch")
public class TmsAiDispatchController extends BaseController
{
    @Resource
    private TransportRouteViMapper transportRouteViMapper;

    @Resource
    private TmsCustomerInfoMapper tmsCustomerInfoMapper;

    @Resource
    private TmsServiceProviderMapper tmsServiceProviderMapper;

    @Resource
    private TmsDriverMapper tmsDriverMapper;

    @Resource
    private TmsVehicleMapper tmsVehicleMapper;

    @Resource
    private TmsConsignorMapper tmsConsignorMapper;

    @Autowired
    private ITmsDispatchOrderService tmsDispatchOrderService;

    @Autowired
    private SysDictDataMapper sysDictDataMapper;

    @Autowired
    private ApiAuthUtil apiAuthUtil;

    /**
     * 验证客户是否存在，且返回客户信息接口
     * @param customerName
     * @return
     */
    @GetMapping("/getCustomerData")
    public AjaxResult getCustomerData(  @RequestParam(value = "customerName", required = true) String customerName){
        logger.info("getCustomerData:{}",customerName);
        TmsCustomerInfo tmsCustomerInfo = tmsCustomerInfoMapper.selectOne(new LambdaQueryWrapper<TmsCustomerInfo>()
                .like(TmsCustomerInfo::getCustomerFullName, customerName)
                .last("limit 1")
        );
        if (tmsCustomerInfo == null){
            return error("客户不存在");
        }else{
            return AjaxResult.success(tmsCustomerInfo);
        }

    }

    /**
     * 验证车辆是否存在，且返回车辆信息接口
     * @param licensePlate
     * @param licenseHk
     * @param licenseMo
     * @return
     */
    @GetMapping("/getVehicleData")
    public AjaxResult getVehicleData(
            @RequestParam(value = "licensePlate", required = false) String licensePlate,
            @RequestParam(value = "licenseHk", required = false) String licenseHk,
            @RequestParam(value = "licenseMo", required = false) String licenseMo,
            @RequestParam(value = "serviceProviderId", required = false) Integer serviceProviderId

    ){
        logger.info("getVehicleData:{},{},{}",licensePlate,licenseHk,licenseMo);

        TmsVehicle tmsCustomerInfo = tmsVehicleMapper.selectOne(new LambdaQueryWrapper<TmsVehicle>()
                .like(StringUtils.isNotEmpty(licensePlate),TmsVehicle::getLicensePlate, licensePlate)
                .like(StringUtils.isNotEmpty(licenseHk),TmsVehicle::getLicenseHk, licenseHk)
                .like(StringUtils.isNotEmpty(licenseMo),TmsVehicle::getLicenseMo, licenseMo)
                .like(serviceProviderId != null,TmsVehicle::getServiceProviderId, serviceProviderId)
                .last("limit 1")
        );
        if (tmsCustomerInfo == null){
            return error("车辆不存在");
        }else{
            return AjaxResult.success(tmsCustomerInfo);
        }

    }


    /**
     * 获取司机接口 (公开接口, 无需认证)
     * 支持按名称筛选
     *
     * @param driverName 司机名称(可选，模糊查询)
     * @return 司机列表
     */
    @GetMapping("/getDriverData")
    public AjaxResult getDriverData(
            @RequestParam(value = "driverName", required = true) String driverName,
            @RequestParam(value = "vehicleProviderId", required = false) Integer vehicleProviderId
            )
    {
        logger.info("getVehicleData:{}",driverName);

        TmsDriver tmsDriver = tmsDriverMapper.selectOne(new LambdaQueryWrapper<TmsDriver>()
                .like(TmsDriver::getDriverName, driverName)
                        .eq(vehicleProviderId !=null,TmsDriver::getVehicleProviderId, vehicleProviderId)
                .last("limit 1")
        );

        if (tmsDriver == null){
            return error("司机信息不存在");
        }else{
            return AjaxResult.success(tmsDriver);
        }

    }
    @GetMapping("/getVehicleProviderData")
    public AjaxResult getVehicleProviderData(
            @RequestParam(value = "serviceName", required = true) String serviceName)
    {
        logger.info("getVehicleProviderData:{}",serviceName);

        TmsServiceProvider provider = tmsServiceProviderMapper.selectOne(new LambdaQueryWrapper<TmsServiceProvider>()
                .like(TmsServiceProvider::getServiceName, serviceName)
                .last("limit 1")
        );

        if (provider == null){
            return error("车辆服务商信息不存在");
        }else{
            return AjaxResult.success(provider);
        }

    }

    @GetMapping("/getConsignorData")
    public AjaxResult getConsignorData(
            @RequestParam(value = "consignorName", required = true) String consignorName,
            @RequestParam(value = "customerName", required = true) String customerName)
    {
        logger.info("getConsignorData:{}",consignorName);

        TmsConsignor tmsConsignor = tmsConsignorMapper.selectOne(new LambdaQueryWrapper<TmsConsignor>()
                .like(TmsConsignor::getConsignorName, consignorName)
                .eq(TmsConsignor::getCustomerName, customerName)
                .last("limit 1")
        );

        if (tmsConsignor == null){
            return error("装卸货点不存在");
        }else{
            return AjaxResult.success(tmsConsignor);
        }
    }



    /**
     * 路线验证接口 (需要appId/secret认证)
     *
     * @param vo 路线验证请求
     * @param request HTTP请求
     * @return 验证结果
     */
    @PostMapping("/validateRoute")
    public AjaxResult validateRoute(@RequestBody RouteValidationVO vo, HttpServletRequest request)
    {
        logger.info("validateRoute:{}", JSONUtil.toJsonStr(vo));
        AiValidationResultVO result = new AiValidationResultVO();
        List<String> errors = new ArrayList<>();
        List<String> warnings = new ArrayList<>();

        // 验证必填字段
        if (StringUtils.isEmpty(vo.getOriginCity())) {
            errors.add("起始城市不能为空");
        }
        if (StringUtils.isEmpty(vo.getDestCity())) {
            errors.add("目的地城市不能为空");
        }
        if (StringUtils.isEmpty(vo.getVehicleType())) {
            errors.add("车辆类型不能为空");
        }

        // 如果有错误，直接返回
        if (!errors.isEmpty()) {
            result.setIsValid(false);
            result.setErrors(errors);
            result.setWarnings(warnings);
            return success(result);
        }

        // 查询匹配的路线
        LambdaQueryWrapper<TransportRouteVi> wrapper = new LambdaQueryWrapper<>();
        if (StringUtils.isNotEmpty(vo.getOriginCity())) {
            wrapper.like(TransportRouteVi::getTransportRoute, vo.getOriginCity());
        }
        if (StringUtils.isNotEmpty(vo.getDestCity())) {
            wrapper.like(TransportRouteVi::getTransportRoute, vo.getDestCity());
        }
        wrapper.eq(TransportRouteVi::getVehicleType, vo.getVehicleType());
        wrapper.eq(TransportRouteVi::getCustomerFullName, vo.getCustomerName());

        List<TransportRouteVi> routes = transportRouteViMapper.selectList(wrapper);

        Map<String, Object> data = new HashMap<>();
        data.put("matchedRoutes", routes);
        data.put("routeCount", routes.size());

        if (routes.isEmpty()) {
            warnings.add("未找到匹配的运输路线");
        }

        result.setIsValid(routes.size() > 0);
        result.setErrors(errors);
        result.setWarnings(warnings);
        result.setData(data);

        return success(result);
    }

    /**
     * 创建调度单接口 (AI优化版, 需要appId/secret认证)
     *
     * @param order AI调度单请求对象
     * @param request HTTP请求
     * @return 创建结果
     */
    @PostMapping("/createOrder")
    public AjaxResult createOrder(@RequestBody TmsDispatchOrder order, HttpServletRequest request)
    {
        // appId/secret 认证
        if (!apiAuthUtil.validateAppAuth(request)) {
            return apiAuthUtil.getUnauthorizedResult();
        }

        try {
            // ========== 1. 客户验证 ==========
            if (StringUtils.isEmpty(order.getCustomerName())) {
                return error("客户名称不能为空");
            }
            TmsCustomerInfo customer = tmsCustomerInfoMapper.selectOne(new LambdaQueryWrapper<TmsCustomerInfo>()
                    .like(TmsCustomerInfo::getCustomerFullName, order.getCustomerName())
                    .last("limit 1")
            );
            if (customer == null) {
                return error("客户不存在，请确认客户名称或先在系统中维护客户信息");
            }
            order.setCustomerId(customer.getId());

            // ========== 2. 车型验证 ==========
            if (StringUtils.isEmpty(order.getRequiredVehicleTypes())) {
                return error("车型不能为空");
            }
            List<SysDictData> vehicleTypes = sysDictDataMapper.selectDictDataByType("vehicle_type");
            boolean vehicleTypeValid = vehicleTypes.stream()
                    .anyMatch(dict -> dict.getDictValue().equals(order.getRequiredVehicleTypes()));
            if (!vehicleTypeValid) {
                return error("车型不存在，请确认车型或先在字典中维护车型数据");
            }

            // ========== 3. 装货点验证（如果提供了装货点名称）==========
            if (StringUtils.isNotEmpty(order.getShipperName())) {
                TmsConsignor shipper = tmsConsignorMapper.selectOne(new LambdaQueryWrapper<TmsConsignor>()
                        .like(TmsConsignor::getConsignorName, order.getShipperName())
                        .eq(TmsConsignor::getCustomerName, order.getCustomerName())
                        .last("limit 1")
                );
                if (shipper == null) {
                    return error("装货点不存在，请确认装货点名称或先在系统中维护装货点信息");
                }
                order.setShipperId(shipper.getId());
            }

            // ========== 4. 卸货点验证（如果提供了卸货点名称）==========
            if (StringUtils.isNotEmpty(order.getReceiverName())) {
                TmsConsignor receiver = tmsConsignorMapper.selectOne(new LambdaQueryWrapper<TmsConsignor>()
                        .like(TmsConsignor::getConsignorName, order.getReceiverName())
                        .eq(TmsConsignor::getCustomerName, order.getCustomerName())
                        .last("limit 1")
                );
                if (receiver == null) {
                    return error("卸货点不存在，请确认卸货点名称或先在系统中维护卸货点信息");
                }
                order.setReceiverId(receiver.getId());
            }

            // ========== 5. 路线验证（AI必须传quoteDetailId）==========
            if (order.getQuoteDetailId() == null) {
                return error("报价明细ID不能为空，请先调用validateRoute接口获取可用路线并选择一条");
            }

            // 根据quoteDetailId查询路线信息
            TransportRouteVi route = transportRouteViMapper.selectById(order.getQuoteDetailId());
            if (route == null) {
                return error("报价明细不存在，请确认报价明细ID是否正确");
            }

            // 验证路线是否匹配客户
            if (!route.getCustomerFullName().equals(order.getCustomerName())) {
                return error("报价明细与客户不匹配，请确认选择的路线是否属于该客户");
            }

            // 验证路线是否匹配车型
            Integer vehicleTypeInt = null;
            try {
                vehicleTypeInt = Integer.parseInt(order.getRequiredVehicleTypes());
            } catch (NumberFormatException e) {
                return error("车型格式错误");
            }
            if (!route.getVehicleType().equals(vehicleTypeInt)) {
                return error("报价明细与车型不匹配，请确认选择的路线车型是否正确");
            }

            // 使用路线信息填充订单
            order.setTransportLine(route.getTransportRoute());
            order.setStartRegionCode(route.getStartRegionCode());
            order.setEndRegionCode(route.getEndRegionCode());
            order.setProjectId(route.getProjectId());
            order.setProjectName(route.getProjectName());
            order.setContractId(route.getContractId());
            order.setContractName(route.getContractName());

            // ========== 6. 订单类型判断 & 必填校验 ==========
            Integer orderType = order.getOrderType();
            if (orderType == null) {
                return error("订单类型不能为空");
            }

            // 基础订单(0)：装货地+卸货地必须齐全
            if (orderType == 0) {
                if (StringUtils.isEmpty(order.getShipperRegionLabel()) || StringUtils.isEmpty(order.getReceiverRegionLabel())) {
                    return error("基础订单的装货地和卸货地不能为空");
                }
            }
            // 预配订单(1)：卸货地可为空，但装货地必须有
            else if (orderType == 1) {
                if (StringUtils.isEmpty(order.getShipperRegionLabel())) {
                    return error("预配订单的装货地不能为空");
                }
            }

            // ========== 7. 派车信息验证 ==========
            // 7.1 司机验证（必填）
            if (order.getMainDriverId() == null) {
                return error("司机信息不能为空");
            }
            TmsDriver driver = tmsDriverMapper.selectById(order.getMainDriverId());
            if (driver == null) {
                return error("司机不存在，请确认司机信息");
            }
            order.setMainDriverName(driver.getDriverName());

            // 7.2 车辆验证（必填）
            if (StringUtils.isEmpty(order.getLicensePlate())) {
                return error("车牌号不能为空");
            }
            TmsVehicle vehicle = tmsVehicleMapper.selectOne(new LambdaQueryWrapper<TmsVehicle>()
                    .eq(TmsVehicle::getLicensePlate, order.getLicensePlate())
                    .last("limit 1")
            );
            if (vehicle == null) {
                return error("车辆不存在，请确认车牌号");
            }
            order.setVehicleId(vehicle.getId());
            order.setActualVehicleType(vehicle.getVehicleType());

            // 7.3 运营模式验证
            Integer operationMode = order.getOperationMode();
            if (operationMode == null) {
                return error("运营模式不能为空（1=自营车队，0=外协）");
            }

            // 7.4 外协模式：必须提供车辆服务商
            if (operationMode == 0) {
                if (order.getVehicleProviderId() == null) {
                    return error("外协模式下，车辆服务商不能为空");
                }
                TmsServiceProvider provider = tmsServiceProviderMapper.selectById(order.getVehicleProviderId());
                if (provider == null) {
                    return error("车辆服务商不存在，请确认服务商信息");
                }
                order.setVehicleProviderName(provider.getServiceName());
            }

            // 设置初始状态为待分配 (0)
            order.setStatus(0);

            // 保存订单
            int result = tmsDispatchOrderService.insertTmsDispatchOrder2(order);

            if (result > 0) {
                // 返回新创建的订单信息
                Map<String, Object> data = new HashMap<>();
                data.put("orderNo", order.getDispatchNo());
                data.put("customerId", order.getCustomerId());
                data.put("customerName", order.getCustomerName());
                data.put("originCity", order.getShipperRegionLabel());
                data.put("destCity", order.getReceiverRegionLabel());
                data.put("transportLine", order.getTransportLine());
                data.put("vehicleType", order.getRequiredVehicleTypes());
                data.put("mainDriverName", order.getMainDriverName());
                data.put("licensePlate", order.getLicensePlate());
                data.put("operationMode", order.getOperationMode());
                data.put("vehicleProviderName", order.getVehicleProviderName());
                data.put("status", order.getStatus());
                return success(data);
            } else {
                return error("创建调度单失败");
            }
        } catch (Exception e) {
            logger.error("创建调度单异常: ", e);
            return error("创建调度单异常: " + e.getMessage());
        }
    }

    /**
     * 获取字典数据接口 (公开接口, 无需认证)
     * 支持多个字典类型，用逗号分隔
     *
     * @param dictTypes 字典类型，逗号分隔
     * @return 字典数据
     */
    @GetMapping("/getDictData")
    public AjaxResult getDictData(@RequestParam(value = "dictTypes", required = false) String dictTypes)
    {
        Map<String, List<DictDataVO>> dictDataMap = new HashMap<>();

        if (StringUtils.isNotEmpty(dictTypes)) {
            String[] types = dictTypes.split(",");
            for (String type : types) {
                String trimmedType = type.trim();
                // 调用Mapper按字典类型查询字典数据
                List<SysDictData> dictDataList = sysDictDataMapper.selectDictDataByType(trimmedType);

                // 转换为VO列表
                List<DictDataVO> voList = new ArrayList<>();
                if (dictDataList != null && !dictDataList.isEmpty()) {
                    voList = dictDataList.stream().map(dictData -> {
                        DictDataVO vo = new DictDataVO(
                            dictData.getDictLabel(),
                            dictData.getDictValue(),
                            dictData.getDictType()
                        );
                        return vo;
                    }).collect(Collectors.toList());
                }

                dictDataMap.put(trimmedType, voList);
            }
        }

        return success(dictDataMap);
    }




}