package com.ruoyi.jarvis.util;

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 腾讯文档数据解析工具类
 * 用于解析腾讯文档 V3 API 返回的复杂数据格式
 * 
 * @author system
 */
public class TencentDocDataParser {
    
    private static final Logger log = LoggerFactory.getLogger(TencentDocDataParser.class);
    
    /**
     * 解析腾讯文档 V3 API 返回的数据为简单的二维数组格式
     * 根据官方文档，响应格式为：{ "ret": 0, "msg": "Succeed", "data": { "gridData": {...} } }
     * 
     * @param apiResponse API响应（可能包含 data.gridData、gridData 或 values 字段）
     * @return 二维数组格式的数据，每行是一个JSONArray
     */
    public static JSONArray parseToSimpleArray(JSONObject apiResponse) {
        if (apiResponse == null) {
            return new JSONArray();
        }
        
        // 方式1：检查是否有 data.gridData 字段（官方V3 API格式）
        JSONObject data = apiResponse.getJSONObject("data");
        if (data != null) {
            JSONObject gridData = data.getJSONObject("gridData");
            if (gridData != null) {
                log.debug("使用 data.gridData 格式解析");
                return parseGridData(gridData);
            }
        }
        
        // 方式2：检查是否有 gridData 字段（直接格式）
        JSONObject gridData = apiResponse.getJSONObject("gridData");
        if (gridData != null) {
            log.debug("使用 gridData 格式解析");
            return parseGridData(gridData);
        }
        
        // 方式3：检查是否有 values 字段（简单格式）
        JSONArray values = apiResponse.getJSONArray("values");
        if (values != null) {
            log.debug("使用 values 格式解析");
            return values;
        }
        
        // 如果都没有，返回空数组
        log.warn("API响应中既没有 data.gridData、gridData 也没有 values 字段，返回空数组");
        return new JSONArray();
    }
    
    /**
     * 解析 gridData 格式的数据
     * 
     * @param gridData gridData 对象
     * @return 二维数组格式的数据
     */
    private static JSONArray parseGridData(JSONObject gridData) {
        JSONArray result = new JSONArray();
        
        // 获取 rows 数组
        JSONArray rows = gridData.getJSONArray("rows");
        if (rows == null || rows.isEmpty()) {
            log.debug("gridData.rows 为空");
            return result;
        }
        
        // 遍历每一行
        for (int i = 0; i < rows.size(); i++) {
            JSONObject row = rows.getJSONObject(i);
            if (row == null) {
                continue;
            }
            
            // 获取这一行的 values 数组
            JSONArray cellValues = row.getJSONArray("values");
            if (cellValues == null) {
                continue;
            }
            
            // 解析每个单元格
            JSONArray rowData = new JSONArray();
            for (int j = 0; j < cellValues.size(); j++) {
                JSONObject cell = cellValues.getJSONObject(j);
                String cellText = extractCellText(cell);
                rowData.add(cellText);
            }
            
            result.add(rowData);
        }
        
        log.debug("成功解析 gridData，共 {} 行", result.size());
        return result;
    }
    
    /**
     * 从单元格对象中提取文本内容
     * 支持多种单元格类型：text（普通文本）、link（超链接）等
     * 
     * @param cell 单元格对象
     * @return 文本内容（如果没有则返回空字符串）
     */
    private static String extractCellText(JSONObject cell) {
        if (cell == null) {
            return "";
        }
        
        // 获取 cellValue
        JSONObject cellValue = cell.getJSONObject("cellValue");
        if (cellValue == null) {
            return "";
        }
        
        // 优先级1：检查是否有 link 字段（超链接类型）
        // 格式：{"cellValue": {"link": {"url": "xxx", "text": "xxx"}}}
        JSONObject link = cellValue.getJSONObject("link");
        if (link != null) {
            // 优先返回 text，如果没有则返回 url
            String linkText = link.getString("text");
            if (linkText != null && !linkText.isEmpty()) {
                log.debug("提取link类型单元格，text: {}", linkText);
                return linkText;
            }
            String linkUrl = link.getString("url");
            if (linkUrl != null && !linkUrl.isEmpty()) {
                log.debug("提取link类型单元格，url: {}", linkUrl);
                return linkUrl;
            }
        }
        
        // 优先级2：检查是否有 text 字段（普通文本类型）
        // 格式：{"cellValue": {"text": "xxx"}}
        String text = cellValue.getString("text");
        if (text != null) {
            return text;
        }
        
        // 优先级3：检查其他可能的字段
        // 数字类型
        if (cellValue.containsKey("number")) {
            Object number = cellValue.get("number");
            return number != null ? number.toString() : "";
        }
        
        // 布尔类型
        if (cellValue.containsKey("bool")) {
            Object bool = cellValue.get("bool");
            return bool != null ? bool.toString() : "";
        }
        
        // 如果都没有，返回空字符串
        return "";
    }
    
    /**
     * 获取指定行的数据
     * 
     * @param apiResponse API响应
     * @param rowIndex 行索引（从0开始）
     * @return 该行的数据数组，如果行不存在则返回 null
     */
    public static JSONArray getRow(JSONObject apiResponse, int rowIndex) {
        JSONArray allRows = parseToSimpleArray(apiResponse);
        if (allRows == null || rowIndex < 0 || rowIndex >= allRows.size()) {
            return null;
        }
        return allRows.getJSONArray(rowIndex);
    }
    
    /**
     * 获取指定单元格的文本内容
     * 
     * @param apiResponse API响应
     * @param rowIndex 行索引（从0开始）
     * @param colIndex 列索引（从0开始）
     * @return 单元格文本内容，如果不存在则返回 null
     */
    public static String getCellText(JSONObject apiResponse, int rowIndex, int colIndex) {
        JSONArray row = getRow(apiResponse, rowIndex);
        if (row == null || colIndex < 0 || colIndex >= row.size()) {
            return null;
        }
        return row.getString(colIndex);
    }
    
    /**
     * 打印数据结构（用于调试）
     * 
     * @param apiResponse API响应
     * @param maxRows 最多打印多少行（0表示全部）
     */
    public static void printDataStructure(JSONObject apiResponse, int maxRows) {
        JSONArray rows = parseToSimpleArray(apiResponse);
        if (rows == null || rows.isEmpty()) {
            log.info("数据为空");
            return;
        }
        
        int rowsToPrint = (maxRows > 0 && maxRows < rows.size()) ? maxRows : rows.size();
        log.info("数据结构（共 {} 行，显示前 {} 行）：", rows.size(), rowsToPrint);
        
        for (int i = 0; i < rowsToPrint; i++) {
            JSONArray row = rows.getJSONArray(i);
            if (row != null) {
                log.info("  第 {} 行（{}列）: {}", i + 1, row.size(), row.toJSONString());
            }
        }
    }

    /**
     * 表头规范化：去 BOM、首尾空白、不间断空格与全角空格后，去掉中间空白再比较（与腾讯表格展示列名一致）
     */
    public static String normalizeTencentDocHeader(String raw) {
        if (raw == null) {
            return "";
        }
        String t = raw.trim();
        if (t.startsWith("\uFEFF")) {
            t = t.substring(1).trim();
        }
        t = t.replace('\u00A0', ' ').replace('\u3000', ' ');
        t = t.replaceAll("\\s+", "");
        return t;
    }

    /**
     * 表头是否与期望列名完全一致（规范化后）
     */
    public static boolean headerEquals(String raw, String expectedName) {
        if (expectedName == null) {
            return false;
        }
        return expectedName.equals(normalizeTencentDocHeader(raw));
    }

    /**
     * 表头是否为「京东下单订单号」列（列名须完全一致）
     */
    public static boolean isJdPlaceOrderNoHeader(String cellValueTrim) {
        return headerEquals(cellValueTrim, "京东下单订单号");
    }
}

