package com.vincent.rsf.server.ai.tool;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.BasStation;
import com.vincent.rsf.server.manager.entity.Warehouse;
import com.vincent.rsf.server.manager.service.BasStationService;
import com.vincent.rsf.server.manager.service.WarehouseService;
import com.vincent.rsf.server.system.entity.DictData;
import com.vincent.rsf.server.system.service.DictDataService;
import lombok.RequiredArgsConstructor;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.ai.tool.annotation.ToolParam;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Component
@RequiredArgsConstructor
public class RsfWmsBaseTools {

    private final WarehouseService warehouseService;
    private final BasStationService basStationService;
    private final DictDataService dictDataService;

    @Tool(name = "rsf_query_warehouses", description = "按仓库编码或名称查询仓库基础信息。")
    public List<Map<String, Object>> queryWarehouses(
            @ToolParam(description = "仓库编码，可选") String code,
            @ToolParam(description = "仓库名称，可选") String name,
            @ToolParam(description = "返回条数，默认 10，最大 50") Integer limit) {
        LambdaQueryWrapper<Warehouse> queryWrapper = new LambdaQueryWrapper<>();
        int finalLimit = normalizeLimit(limit, 10, 50);
        if (StringUtils.hasText(code)) {
            queryWrapper.like(Warehouse::getCode, code);
        }
        if (StringUtils.hasText(name)) {
            queryWrapper.like(Warehouse::getName, name);
        }
        queryWrapper.orderByAsc(Warehouse::getCode).last("LIMIT " + finalLimit);
        List<Warehouse> warehouses = warehouseService.list(queryWrapper);
        List<Map<String, Object>> result = new ArrayList<>();
        for (Warehouse warehouse : warehouses) {
            Map<String, Object> item = new LinkedHashMap<>();
            item.put("id", warehouse.getId());
            item.put("code", warehouse.getCode());
            item.put("name", warehouse.getName());
            item.put("factory", warehouse.getFactory());
            item.put("address", warehouse.getAddress());
            item.put("status", warehouse.getStatus());
            item.put("statusLabel", warehouse.getStatus$());
            item.put("memo", warehouse.getMemo());
            result.add(item);
        }
        return result;
    }

    @Tool(name = "rsf_query_bas_stations", description = "按站点编号、站点名称或使用状态查询基础站点。")
    public List<Map<String, Object>> queryBasStations(
            @ToolParam(description = "站点编号，可选") String stationName,
            @ToolParam(description = "站点名称，可选") String stationId,
            @ToolParam(description = "使用状态，可选") String useStatus,
            @ToolParam(description = "返回条数，默认 10，最大 50") Integer limit) {
        LambdaQueryWrapper<BasStation> queryWrapper = new LambdaQueryWrapper<>();
        int finalLimit = normalizeLimit(limit, 10, 50);
        if (StringUtils.hasText(stationName)) {
            queryWrapper.like(BasStation::getStationName, stationName);
        }
        if (StringUtils.hasText(stationId)) {
            queryWrapper.like(BasStation::getStationId, stationId);
        }
        if (StringUtils.hasText(useStatus)) {
            queryWrapper.eq(BasStation::getUseStatus, useStatus);
        }
        queryWrapper.orderByAsc(BasStation::getStationName).last("LIMIT " + finalLimit);
        List<BasStation> stations = basStationService.list(queryWrapper);
        List<Map<String, Object>> result = new ArrayList<>();
        for (BasStation station : stations) {
            Map<String, Object> item = new LinkedHashMap<>();
            item.put("id", station.getId());
            item.put("stationName", station.getStationName());
            item.put("stationId", station.getStationId());
            item.put("type", station.getType());
            item.put("typeLabel", station.getType$());
            item.put("useStatus", station.getUseStatus());
            item.put("useStatusLabel", station.getUseStatus$());
            item.put("area", station.getArea());
            item.put("areaLabel", station.getArea$());
            item.put("isWcs", station.getIsWcs());
            item.put("inAble", station.getInAble());
            item.put("outAble", station.getOutAble());
            item.put("status", station.getStatus());
            result.add(item);
        }
        return result;
    }

    @Tool(name = "rsf_query_dict_data", description = "根据字典类型编码查询字典数据，可按值或标签进一步过滤。")
    public List<Map<String, Object>> queryDictData(
            @ToolParam(required = true, description = "字典类型编码") String dictTypeCode,
            @ToolParam(description = "字典值，可选") String value,
            @ToolParam(description = "字典标签，可选") String label,
            @ToolParam(description = "返回条数，默认 20，最大 100") Integer limit) {
        if (!StringUtils.hasText(dictTypeCode)) {
            throw new CoolException("字典类型编码不能为空");
        }
        int finalLimit = normalizeLimit(limit, 20, 100);
        LambdaQueryWrapper<DictData> queryWrapper = new LambdaQueryWrapper<DictData>()
                .eq(DictData::getDictTypeCode, dictTypeCode);
        if (StringUtils.hasText(value)) {
            queryWrapper.like(DictData::getValue, value);
        }
        if (StringUtils.hasText(label)) {
            queryWrapper.like(DictData::getLabel, label);
        }
        queryWrapper.orderByAsc(DictData::getSort).last("LIMIT " + finalLimit);
        List<DictData> dictDataList = dictDataService.list(queryWrapper);
        List<Map<String, Object>> result = new ArrayList<>();
        for (DictData dictData : dictDataList) {
            Map<String, Object> item = new LinkedHashMap<>();
            item.put("id", dictData.getId());
            item.put("dictTypeCode", dictData.getDictTypeCode());
            item.put("value", dictData.getValue());
            item.put("label", dictData.getLabel());
            item.put("sort", dictData.getSort());
            item.put("color", dictData.getColor());
            item.put("group", dictData.getGroup());
            item.put("status", dictData.getStatus());
            item.put("statusLabel", dictData.getStatus$());
            result.add(item);
        }
        return result;
    }

    private int normalizeLimit(Integer limit, int defaultValue, int maxValue) {
        if (limit == null) {
            return defaultValue;
        }
        if (limit < 1 || limit > maxValue) {
            throw new CoolException("limit 必须在 1 到 " + maxValue + " 之间");
        }
        return limit;
    }
}