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

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.openApi.entity.dto.CommonResponse;
import com.vincent.rsf.openApi.entity.phyz.*;
import com.vincent.rsf.openApi.feign.wms.WmsServerFeignClient;
import com.vincent.rsf.openApi.feign.wms.fallback.WmsServerFeignClientFallback;
import com.vincent.rsf.openApi.service.phyz.ErpReportService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
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;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;

import static com.vincent.rsf.openApi.controller.AuthController.SIMULATED_DATA_ENABLE;

@RestController
@RequestMapping("/erp")
@Api("银座新工厂（五期）ERP接口")
@Slf4j
public class ERPController {

    public static JSONArray map = new JSONArray();

    @Resource
    private ErpReportService erpReportService;

    @Autowired(required = false)
    private WmsServerFeignClient wmsServerFeignClient;


    @ApiOperation("仓库信息同步")
    @PostMapping("/wareHouse/sync")
    public CommonResponse syncWareHouse(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        List<Warehouse> warehouseList = JSON.parseArray(params.toJSONString(), Warehouse.class);
        // 数据处理，转发server
        return CommonResponse.ok();
    }

    @ApiOperation("物料信息同步")
    @PostMapping("/mat/sync")
    public CommonResponse syncMaterial(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        List<Material> materialList = JSON.parseArray(params.toJSONString(), Material.class);
        // 数据处理，转发server
        return CommonResponse.ok();
    }

    @ApiOperation("客户信息同步")
    @PostMapping("/customer/sync")
    public CommonResponse syncCustomer(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        List<Customer> customerList = JSON.parseArray(params.toJSONString(), Customer.class);
        // 数据处理，转发server
        return CommonResponse.ok();
    }

    @ApiOperation("供应商信息同步")
    @PostMapping("/supplier/sync")
    public CommonResponse syncSupplier(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        List<Supplier> supplierList = JSON.parseArray(params.toJSONString(), Supplier.class);
        // 数据处理，转发server
        return CommonResponse.ok();
    }

    @ApiOperation("入/出库任务通知单")
    @PostMapping("/order/add")
    public CommonResponse addOrder(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        List<Order> orderList = JSON.parseArray(params.toJSONString(), Order.class);
        // 数据处理，转发server
        StringBuffer errorMsg = new StringBuffer();
        for (Order order : orderList) {
            String i = erpReportService.addOrderToServer(order);
            if (i.equals("200")){
                errorMsg.append(order.getOrderNo()+"下发成功;");
            } else {
                errorMsg.append(order.getOrderNo()+"下发失败,原因："+i+";");
            }
        }
        return CommonResponse.ok(errorMsg.toString());
    }

    @ApiOperation("入/出库任务通知单取消")
    @PostMapping("/order/cancel")
    public CommonResponse cancelOrder(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        List<Order> orderList = JSON.parseArray(params.toJSONString(), Order.class);
        // 数据处理，转发server
        return CommonResponse.ok();
    }

    @ApiOperation("库存查询明细（表单提交）")
    @PostMapping(value = "/inventory/details", consumes = "application/x-www-form-urlencoded")
    public CommonResponse queryInventoryDetailsForm(HttpServletRequest request) {
        // 从表单参数构建查询条件
        InventoryQueryCondition condition = buildConditionFromRequestParams(request);
        // 调用JSON处理方法
        return queryInventoryDetails(condition);
    }

    @ApiOperation("库存查询明细")
    @PostMapping(value = "/inventory/details", consumes = "application/json")
    public CommonResponse queryInventoryDetails(@RequestBody(required = false) InventoryQueryCondition condition) {
        // JSON方式：支持不传递参数（{}或null或空请求体），创建默认的空查询条件对象
        if (condition == null) {
            condition = new InventoryQueryCondition();
        }
        
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            String x = "[\n" +
                    "  {\n" +
                    "    \"locId\": \"LOC-A-01-01\",\n" +
                    "    \"wareHouseId\": \"WH001\",\n" +
                    "    \"wareHouseName\": \"原料仓库\",\n" +
                    "    \"palletId\": \"PALLET001\",\n" +
                    "    \"matNr\": \"MAT10001\",\n" +
                    "    \"makTx\": \"钢材Q235\",\n" +
                    "    \"spec\": \"国标GB/T700-2006\",\n" +
                    "    \"anfme\": 10.5,\n" +
                    "    \"unit\": \"吨\",\n" +
                    "    \"status\": \"可用\",\n" +
                    "    \"orderType\": 1,\n" +
                    "    \"orderNo\": \"Order202698921\",\n" +
                    "    \"prepareType\": 1,\n" +
                    "    \"planNo\": \"PLAN202601060001\",\n" +
                    "    \"batch\": \"BATCH20260106001\",\n" +
                    "    \"stockOrgId\": \"ORG001\"\n" +
                    "  },\n" +
                    "  {\n" +
                    "    \"locId\": \"LOC-B-02-03\",\n" +
                    "    \"wareHouseId\": \"WH002\",\n" +
                    "    \"wareHouseName\": \"成品仓库\",\n" +
                    "    \"palletId\": \"PALLET002\",\n" +
                    "    \"matNr\": \"MAT20001\",\n" +
                    "    \"makTx\": \"电机组件\",\n" +
                    "    \"spec\": \"380V 50Hz\",\n" +
                    "    \"anfme\": 50,\n" +
                    "    \"unit\": \"台\",\n" +
                    "    \"status\": \"可用\",\n" +
                    "    \"orderType\": \"1\",\n" +
                    "    \"orderNo\": \"SO202601060001\",\n" +
                    "    \"prepareType\": 1,\n" +
                    "    \"planNo\": \"PLAN202601060002\",\n" +
                    "    \"batch\": \"BATCH20260106002\",\n" +
                    "    \"stockOrgId\": \"ORG001\"\n" +
                    "  }\n" +
                    "]";
            if (map == null || map.isEmpty()) {
                map = JSON.parseArray(x);
            }
            return CommonResponse.ok(JSONArray.parseArray(map.toJSONString(), InventoryDetails.class));
        }

        try {
            if (wmsServerFeignClient == null) {
                log.warn("WmsServerFeignClient未注入，无法进行调用");
                return CommonResponse.error("服务未初始化");
            }
            
            log.info("库存查询明细请求参数： {}", JSON.toJSONString(condition));
            
            // 直接传递实体类，Feign会自动序列化为JSON
            R result = wmsServerFeignClient.queryInventoryDetails(condition);
            
            log.info("库存查询明细返回结果： {}", JSON.toJSONString(result));
            
            if (result != null) {
                // R类继承自HashMap，使用get方法获取值
                Integer code = (Integer) result.get("code");
                String msg = (String) result.get("msg");
                Object data = result.get("data");
                
                if (code != null && code == 200) {
                    // 将Map列表转换为InventoryDetails列表
                    if (data != null) {
                        @SuppressWarnings("unchecked")
                        List<Map<String, Object>> dataList = (List<Map<String, Object>>) data;
                        List<InventoryDetails> inventoryDetails = new ArrayList<>();
                        for (Map<String, Object> item : dataList) {
                            InventoryDetails details = JSON.parseObject(JSON.toJSONString(item), InventoryDetails.class);
                            inventoryDetails.add(details);
                        }
                        return CommonResponse.ok(inventoryDetails);
                    } else {
                        return CommonResponse.ok(new ArrayList<>());
                    }
                } else {
                    return CommonResponse.error(msg != null ? msg : "查询失败");
                }
            } else {
                return CommonResponse.error("查询失败：返回结果为空");
            }
        } catch (Exception e) {
            log.error("库存查询明细失败", e);
            String errorMessage = WmsServerFeignClientFallback.filterErrorMessage(e);
            return CommonResponse.error(errorMessage);
        }
    }

    @ApiOperation("库存查询汇总（表单提交）")
    @PostMapping(value = "/inventory/summary", consumes = "application/x-www-form-urlencoded")
    public CommonResponse queryInventorySummaryForm(HttpServletRequest request) {
        // 从表单参数构建查询条件
        InventoryQueryCondition condition = buildConditionFromRequestParams(request);
        // 调用JSON处理方法
        return queryInventorySummary(condition);
    }

    @ApiOperation("库存查询汇总")
    @PostMapping(value = "/inventory/summary", consumes = "application/json")
    public CommonResponse queryInventorySummary(@RequestBody(required = false) InventoryQueryCondition condition) {
        // JSON方式：支持不传递参数（{}或null或空请求体），创建默认的空查询条件对象
        if (condition == null) {
            condition = new InventoryQueryCondition();
        }
        
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            String x = "[\n" +
                    "  {\n" +
                    "    \"wareHouseId\": \"WH001\",\n" +
                    "    \"wareHouseName\": \"原料仓库\",\n" +
                    "    \"matNr\": \"MAT10001\",\n" +
                    "    \"matTx\": \"钢材Q235\",\n" +
                    "    \"spec\": \"国标GB/T700-2006\",\n" +
                    "    \"anfme\": 10.5,\n" +
                    "    \"unit\": \"吨\",\n" +
                    "    \"stockOrgId\": \"ORG001\",\n" +
                    "    \"batch\": \"BATCH20260106001\",\n" +
                    "    \"planNo\": \"Plan20260106006\"\n" +
                    "  },\n" +
                    "  {\n" +
                    "    \"wareHouseId\": \"WH001\",\n" +
                    "    \"wareHouseName\": \"原料仓库\",\n" +
                    "    \"matNr\": \"MAT10002\",\n" +
                    "    \"matTx\": \"铝型材6061\",\n" +
                    "    \"spec\": \"国标GB/T3190-2008\",\n" +
                    "    \"anfme\": 20.3,\n" +
                    "    \"unit\": \"吨\",\n" +
                    "    \"stockOrgId\": \"ORG001\",\n" +
                    "    \"batch\": \"BATCH20260106002\",\n" +
                    "    \"planNo\": \"Plan20260106005\"\n" +
                    "  },\n" +
                    "  {\n" +
                    "    \"wareHouseId\": \"WH002\",\n" +
                    "    \"wareHouseName\": \"成品仓库\",\n" +
                    "    \"matNr\": \"MAT30001\",\n" +
                    "    \"matTx\": \"电机成品\",\n" +
                    "    \"spec\": \"380V 50Hz 15KW\",\n" +
                    "    \"anfme\": 100,\n" +
                    "    \"unit\": \"台\",\n" +
                    "    \"stockOrgId\": \"ORG001\",\n" +
                    "    \"batch\": \"BATCH20260106003\",\n" +
                    "    \"planNo\": \"Plan20260106004\"\n" +
                    "  }\n" +
                    "]";
            return CommonResponse.ok(JSONArray.parseArray(x, InventorySummary.class));
        }

        try {
            if (wmsServerFeignClient == null) {
                log.warn("WmsServerFeignClient未注入，无法进行调用");
                return CommonResponse.error("服务未初始化");
            }
            
            log.info("库存查询汇总请求参数： {}", JSON.toJSONString(condition));
            
            // 直接传递实体类，Feign会自动序列化为JSON
            R result = wmsServerFeignClient.queryInventorySummary(condition);
            
            log.info("库存查询汇总返回结果： {}", JSON.toJSONString(result));
            
            if (result != null) {
                // R类继承自HashMap，使用get方法获取值
                Integer code = (Integer) result.get("code");
                String msg = (String) result.get("msg");
                Object data = result.get("data");
                
                if (code != null && code == 200) {
                    // 将Map列表转换为InventorySummary列表
                    if (data != null) {
                        @SuppressWarnings("unchecked")
                        List<Map<String, Object>> dataList = (List<Map<String, Object>>) data;
                        List<InventorySummary> inventorySummaries = new ArrayList<>();
                        for (Map<String, Object> item : dataList) {
                            InventorySummary summary = JSON.parseObject(JSON.toJSONString(item), InventorySummary.class);
                            inventorySummaries.add(summary);
                        }
                        return CommonResponse.ok(inventorySummaries);
                    } else {
                        return CommonResponse.ok(new ArrayList<>());
                    }
                } else {
                    return CommonResponse.error(msg != null ? msg : "查询失败");
                }
            } else {
                return CommonResponse.error("查询失败：返回结果为空");
            }
        } catch (Exception e) {
            log.error("库存查询汇总失败", e);
            String errorMessage = WmsServerFeignClientFallback.filterErrorMessage(e);
            return CommonResponse.error(errorMessage);
        }
    }

    @ApiOperation("盘点结果确认")
    @PostMapping("/check/confirm")
    public CommonResponse checkConfirm(@RequestBody Object objParams) {
        if (Objects.isNull(objParams)) {
            throw new CoolException("参数不能为空！！");
        }
        // 返回模拟数据
        if (SIMULATED_DATA_ENABLE.equals("1")) {
            return CommonResponse.ok();
        }

        JSONArray params = paramsFormat(objParams);
        CheckOrder checkResult = JSON.parseObject(params.toJSONString(), CheckOrder.class);
        // 数据处理，转发server
        return CommonResponse.ok();
    }

    /**
     * 兼容JSONObject和JSONArray格式数据
     *
     * @param data json格式参数
     * @return JSONArray格式数据
     */
    public static JSONArray paramsFormat(Object data) {
        if (Objects.isNull(data)) {
            return new JSONArray();
        }

        try {
            String jsonStr = JSON.toJSONString(data);
            if (jsonStr.startsWith("[")) {
                return JSON.parseArray(jsonStr);
            } else if (jsonStr.startsWith("{")) {
                JSONArray params = new JSONArray();
                params.add(JSON.parseObject(jsonStr));
                return params;
            }
        } catch (Exception e) {
            // 解析失败，返回空数组
            log.error("转换参数为json格式错误", e);
        }

        // 默认返回空数组
        return new JSONArray();
    }

    // region 测试推送功能
    @ApiOperation("登录")
    @PostMapping("/loginBySign")
    public CommonResponse loginBySign() {
        try {
            return CommonResponse.ok(erpReportService.loginBySign());
        } catch (Exception e) {
            log.error("erp, loginBySign", e);
        }
        return CommonResponse.ok();
    }

    @ApiOperation("入/出库任务回调")
    @PostMapping("/reportInOrOutBound")
    public CommonResponse reportInOrOutBound(@RequestBody Object objParams) {
        try {
            return erpReportService.reportInOrOutBound(objParams);
        } catch (Exception e) {
            log.error("erp, reportInOrOutBound", e);
        }
        return CommonResponse.ok();
    }
    // endregion


    /**
     * 从请求参数（表单数据）构建查询条件对象
     * 支持 application/x-www-form-urlencoded 格式
     */
    private InventoryQueryCondition buildConditionFromRequestParams(HttpServletRequest request) {
        InventoryQueryCondition condition = new InventoryQueryCondition();
        
        // 从请求参数中获取字段值
        String wareHouseId = request.getParameter("wareHouseId");
        String locId = request.getParameter("locId");
        String matNr = request.getParameter("matNr");
        String matGroup = request.getParameter("matGroup");
        String orderNo = request.getParameter("orderNo");
        String planNo = request.getParameter("planNo");
        String batch = request.getParameter("batch");
        
        // 设置字段值（如果存在）
        if (wareHouseId != null && !wareHouseId.isEmpty()) {
            condition.setWareHouseId(wareHouseId);
        }
        if (locId != null && !locId.isEmpty()) {
            condition.setLocId(locId);
        }
        if (matNr != null && !matNr.isEmpty()) {
            condition.setMatNr(matNr);
        }
        if (matGroup != null && !matGroup.isEmpty()) {
            condition.setMatGroup(matGroup);
        }
        if (orderNo != null && !orderNo.isEmpty()) {
            condition.setOrderNo(orderNo);
        }
        if (planNo != null && !planNo.isEmpty()) {
            condition.setPlanNo(planNo);
        }
        if (batch != null && !batch.isEmpty()) {
            condition.setBatch(batch);
        }
        
        return condition;
    }

}