package com.vincent.rsf.openApi.controller.example;

import com.alibaba.fastjson.JSONObject;
import com.vincent.rsf.openApi.entity.dto.CommonResponse;
import com.vincent.rsf.openApi.utils.ParamsMapUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 接口字段映射使用示例
 * 
 * 展示如何在实际业务中使用 FuncMap 进行字段映射
 * 
 * @author vincent
 * @since 2026-01-04
 */
@Slf4j
@RestController
@RequestMapping("/example/mapping")
@Api(tags = "字段映射使用示例")
public class FieldMappingExampleController {

    /**
     * 示例1：ERP订单接收 - 字段映射
     * 
     * 场景：接收ERP系统的订单数据，字段名与WMS不一致，需要进行映射
     * 
     * ERP字段 -> WMS字段：
     * orderNumber -> code
     * orderQty -> qty
     * orderAmount -> anfme
     */
    @ApiOperation("示例：ERP订单接收")
    @PostMapping("/erp/order/receive")
    public CommonResponse erpOrderReceive(@RequestBody JSONObject requestData) {
        log.info("接收到ERP订单数据（映射前）：{}", requestData);
        
        // 执行字段映射
        String appId = "ERP_SYSTEM";
        String funcId = "ORDER_SYNC";
        JSONObject mappedData = ParamsMapUtils.apiMaps(appId, funcId, requestData);
        
        log.info("字段映射后的数据：{}", mappedData);
        
        // 这里可以继续调用WMS内部的业务逻辑处理映射后的数据
        // orderService.createOrder(mappedData);
        
        return CommonResponse.ok()
                .setMsg("订单接收成功")
                .setData(mappedData);
    }

    /**
     * 示例2：物料信息同步 - 字段映射
     * 
     * 场景：接收ERP系统的物料数据
     * 
     * ERP字段 -> WMS字段：
     * materialCode -> matnr
     * materialName -> maktx
     * materialSpec -> spec
     */
    @ApiOperation("示例：物料信息同步")
    @PostMapping("/erp/material/sync")
    public CommonResponse materialSync(@RequestBody JSONObject requestData) {
        log.info("接收到物料数据（映射前）：{}", requestData);
        
        // 执行字段映射
        String appId = "ERP_SYSTEM";
        String funcId = "MATNR_SYNC";
        JSONObject mappedData = ParamsMapUtils.apiMaps(appId, funcId, requestData);
        
        log.info("字段映射后的数据：{}", mappedData);
        
        return CommonResponse.ok()
                .setMsg("物料同步成功")
                .setData(mappedData);
    }

    /**
     * 示例3：WCS任务创建 - 字段映射
     * 
     * 场景：接收WCS系统的任务创建请求
     * 
     * WCS字段 -> WMS字段：
     * containerCode -> barcode
     * stationCode -> sourceStaNo
     * taskType -> ioType
     */
    @ApiOperation("示例：WCS任务创建")
    @PostMapping("/wcs/task/create")
    public CommonResponse wcsTaskCreate(@RequestBody JSONObject requestData) {
        log.info("接收到WCS任务数据（映射前）：{}", requestData);
        
        // 执行字段映射
        String appId = "WCS_SYSTEM";
        String funcId = "TASK_CREATE";
        JSONObject mappedData = ParamsMapUtils.apiMaps(appId, funcId, requestData);
        
        log.info("字段映射后的数据：{}", mappedData);
        
        return CommonResponse.ok()
                .setMsg("任务创建成功")
                .setData(mappedData);
    }

    /**
     * 示例4：批量数据映射
     * 
     * 场景：批量接收订单明细，需要对每条明细进行字段映射
     */
    @ApiOperation("示例：批量订单明细映射")
    @PostMapping("/erp/order/batch")
    public CommonResponse batchOrderMapping(@RequestBody JSONObject requestData) {
        log.info("接收到批量订单数据");
        
        String appId = "ERP_SYSTEM";
        String funcId = "ORDER_SYNC";
        
        // 映射订单头
        JSONObject orderHeader = requestData.getJSONObject("header");
        JSONObject mappedHeader = ParamsMapUtils.apiMaps(appId, funcId, orderHeader);
        
        // 映射订单明细列表
        com.alibaba.fastjson.JSONArray items = requestData.getJSONArray("items");
        com.alibaba.fastjson.JSONArray mappedItems = new com.alibaba.fastjson.JSONArray();
        
        if (items != null) {
            for (int i = 0; i < items.size(); i++) {
                JSONObject item = items.getJSONObject(i);
                JSONObject mappedItem = ParamsMapUtils.apiMaps(appId, funcId, item);
                mappedItems.add(mappedItem);
            }
        }
        
        // 组装结果
        JSONObject result = new JSONObject();
        result.put("header", mappedHeader);
        result.put("items", mappedItems);
        
        log.info("批量映射完成，共处理 {} 条明细", mappedItems.size());
        
        return CommonResponse.ok()
                .setMsg("批量处理成功")
                .setData(result);
    }

    /**
     * 示例5：条件映射
     * 
     * 场景：根据不同的应用来源，使用不同的映射规则
     */
    @ApiOperation("示例：条件映射")
    @PostMapping("/dynamic/mapping")
    public CommonResponse dynamicMapping(@RequestBody JSONObject requestData) {
        
        // 从请求中获取应用标识
        String source = requestData.getString("source");
        String funcId = requestData.getString("function");
        
        // 移除元数据字段
        requestData.remove("source");
        requestData.remove("function");
        
        log.info("动态映射 - 来源：{}，功能：{}", source, funcId);
        
        // 根据来源选择不同的映射规则
        String appId;
        switch (source) {
            case "ERP":
                appId = "ERP_SYSTEM";
                break;
            case "WCS":
                appId = "WCS_SYSTEM";
                break;
            case "MES":
                appId = "MES_SYSTEM";
                break;
            default:
                return CommonResponse.error("未知的数据源：" + source);
        }
        
        // 执行映射
        JSONObject mappedData = ParamsMapUtils.apiMaps(appId, funcId, requestData);
        
        return CommonResponse.ok()
                .setMsg("动态映射成功")
                .setData(mappedData);
    }
}