package com.ruoyi.jarvis.util;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 线报消息解析工具类
 * 
 * @author ruoyi
 * @date 2025-01-10
 */
public class LineReportParser {

    // 京东链接正则表达式（贪婪匹配，捕获完整URL）
    private static final Pattern JD_URL_PATTERN = Pattern.compile("https?://[^\\s]*jd\\.com[^\\s]*");
    
    // SKUID正则表达式（10-13位数字）
    private static final Pattern SKUID_PATTERN = Pattern.compile("\\b(\\d{10,13})\\b");

    // 行内价格 + 短链接：示例 1428.28    https://u.jd.com/xxxxx
    private static final Pattern PRICE_AND_UJD_PATTERN = Pattern.compile("(?i)\\b(\\d{1,6}(?:\\.\\d{1,2})?)\\b\\s+https?://[^\\s]*u\\.jd\\.com/[^\\s]+");
    // 也支持 URL 在前，后面跟价格： https://u.jd.com/xxxxx   1428.28
    private static final Pattern UJD_AND_PRICE_PATTERN = Pattern.compile("(?i)https?://[^\\s]*u\\.jd\\.com/[^\\s]+\\s+\\b(\\d{1,6}(?:\\.\\d{1,2})?)\\b");
    // 行内价格通用匹配（支持￥/💰/纯数字），用于邻近行回溯
    private static final Pattern PRICE_NEAR_PATTERN = Pattern.compile("[￥💰]?\\s*([0-9]{1,6}(?:\\.[0-9]{1,2})?)");
    // “不高于”价格匹配
    private static final Pattern NOT_HIGHER_PATTERN = Pattern.compile("不高于\\s*([0-9]{1,6}(?:\\.[0-9]{1,2})?)");

    /**
     * 从线报消息中提取所有京东链接
     * 
     * @param message 线报消息
     * @return 京东链接列表
     */
    public static List<String> extractJdUrls(String message) {
        List<String> urls = new ArrayList<>();
        if (message == null || message.trim().isEmpty()) {
            return urls;
        }

        Matcher matcher = JD_URL_PATTERN.matcher(message);
        while (matcher.find()) {
            String url = matcher.group();
            // 清理URL末尾的标点符号
            url = url.replaceAll("[\\s,，。!！?？]+$", "");
            if (!urls.contains(url)) {
                urls.add(url);
            }
        }

        return urls;
    }

    /**
     * 从行文本中提取每个短链接对应的价格（若存在）。
     * 仅关联 u.jd.com 短链，返回 Map<url, price>
     */
    public static Map<String, Double> extractPriceForUrls(String message) {
        Map<String, Double> result = new LinkedHashMap<>();
        if (message == null || message.trim().isEmpty()) {
            return result;
        }

        // 逐行处理，减少跨行误配
        String[] lines = message.split("\r?\n");
        // 预清洗行尾标点，保留原顺序
        for (int i = 0; i < lines.length; i++) {
            if (lines[i] != null) {
                lines[i] = lines[i].trim();
            }
        }
        for (String line : lines) {
            if (line == null || line.trim().isEmpty()) continue;

            // 价格在前 URL 在后
            Matcher m1 = PRICE_AND_UJD_PATTERN.matcher(line);
            while (m1.find()) {
                String priceStr = m1.group(1);
                Double price = parsePrice(priceStr);
                // 从匹配片段中继续提取 URL
                String fragment = m1.group();
                Matcher urlM = JD_URL_PATTERN.matcher(fragment);
                if (price != null && price > 10 && urlM.find()) {
                    String url = urlM.group();
                    url = url.replaceAll("[\\s,，。!！?？]+$", "");
                    result.put(url, price);
                }
            }

            // URL 在前 价格在后
            Matcher m2 = UJD_AND_PRICE_PATTERN.matcher(line);
            while (m2.find()) {
                String fragment = m2.group();
                Matcher urlM = JD_URL_PATTERN.matcher(fragment);
                String url = null;
                if (urlM.find()) {
                    url = urlM.group();
                    url = url.replaceAll("[\\s,，。!！?？]+$", "");
                }
                String priceStr = m2.group(1);
                Double price = parsePrice(priceStr);
                if (url != null && price != null && price > 10) {
                    result.put(url, price);
                }
            }
        }

        // 邻近行补偿：若同一行未抓到价格，则在同一段落内向上回溯2行寻找价格（优先含💰/￥）
        for (int i = 0; i < lines.length; i++) {
            String line = lines[i];
            if (line == null || line.isEmpty()) continue;
            Matcher urlM = JD_URL_PATTERN.matcher(line);
            while (urlM.find()) {
                String url = urlM.group();
                url = url.replaceAll("[\\s,，。!！?？]+$", "");
                if (result.containsKey(url)) {
                    continue; // 已有同一行价格匹配
                }
                // 回溯前两行找价格
                Double price = null;
                for (int k = 1; k <= 2 && i - k >= 0; k++) {
                    String prev = lines[i - k];
                    if (prev == null || prev.isEmpty()) break; // 遇空行认为分段
                    // 优先匹配包含💰或￥的价格
                    Matcher rich = Pattern.compile("[￥💰]\\s*([0-9]{1,6}(?:\\.[0-9]{1,2})?)").matcher(prev);
                    if (rich.find()) {
                        price = parsePrice(rich.group(1));
                        break;
                    }
                    // 其次匹配“不高于 xxxx”
                    Matcher nh = NOT_HIGHER_PATTERN.matcher(prev);
                    if (nh.find()) {
                        price = parsePrice(nh.group(1));
                        break;
                    }
                    Matcher any = PRICE_NEAR_PATTERN.matcher(prev);
                    if (any.find()) {
                        price = parsePrice(any.group(1));
                        // 不break，继续上一行寻找更强标记的价格，若后一行找到rich将覆盖
                    }
                }
                if (price != null && price > 10) {
                    result.put(url, price);
                }
                if (!result.containsKey(url)) {
                    // 前向查找：向下最多2行寻找价格
                    Double fprice = null;
                    for (int k = 1; k <= 2 && i + k < lines.length; k++) {
                        String next = lines[i + k];
                        if (next == null || next.isEmpty()) break; // 空行视为分段
                        // 优先匹配包含💰或￥的价格
                        Matcher richN = Pattern.compile("[￥💰]\\s*([0-9]{1,6}(?:\\.[0-9]{1,2})?)").matcher(next);
                        if (richN.find()) {
                            fprice = parsePrice(richN.group(1));
                            break;
                        }
                        // 其次匹配“不高于 xxxx”
                        Matcher nhN = NOT_HIGHER_PATTERN.matcher(next);
                        if (nhN.find()) {
                            fprice = parsePrice(nhN.group(1));
                            break;
                        }
                        Matcher anyN = PRICE_NEAR_PATTERN.matcher(next);
                        if (anyN.find()) {
                            fprice = parsePrice(anyN.group(1));
                        }
                    }
                    if (fprice != null && fprice > 10) {
                        result.put(url, fprice);
                    }
                }
            }
        }

        return result;
    }

    private static Double parsePrice(String s) {
        try {
            if (s == null) return null;
            String t = s.replace(",", "").trim();
            return Double.parseDouble(t);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 从线报消息中提取所有可能的SKUID
     * 
     * @param message 线报消息
     * @return SKUID列表
     */
    public static List<String> extractSkuids(String message) {
        Set<String> skuids = new LinkedHashSet<>();
        if (message == null || message.trim().isEmpty()) {
            return new ArrayList<>(skuids);
        }

        // 先从URL中提取SKUID
        List<String> urls = extractJdUrls(message);
        for (String url : urls) {
            String skuid = extractSkuidFromUrl(url);
            if (skuid != null) {
                skuids.add(skuid);
            }
        }

        // 再从文本中直接提取可能的SKUID（10-13位数字）
        Matcher matcher = SKUID_PATTERN.matcher(message);
        while (matcher.find()) {
            String skuid = matcher.group(1);
            // 只添加11-13位的，避免误识别（如手机号等）
            if (skuid.length() >= 11) {
                skuids.add(skuid);
            }
        }

        return new ArrayList<>(skuids);
    }

    /**
     * 从JD链接中提取SKUID
     * 
     * @param url JD链接
     * @return SKUID，如果提取失败返回null
     */
    public static String extractSkuidFromUrl(String url) {
        if (url == null || url.trim().isEmpty()) {
            return null;
        }

        // 匹配 item.jd.com/{skuid}.html
        Pattern pattern1 = Pattern.compile("item\\.jd\\.com/(\\d+)\\.html");
        Matcher matcher1 = pattern1.matcher(url);
        if (matcher1.find()) {
            return matcher1.group(1);
        }

        // 匹配 sku=xxx 或 skuId=xxx
        Pattern pattern2 = Pattern.compile("[?&]sku[Ii]?d?=(\\d+)");
        Matcher matcher2 = pattern2.matcher(url);
        if (matcher2.find()) {
            return matcher2.group(1);
        }

        // 匹配短链接中的数字
        Pattern pattern3 = Pattern.compile("u\\.jd\\.com/[^\\s]*(\\d{10,13})");
        Matcher matcher3 = pattern3.matcher(url);
        if (matcher3.find()) {
            return matcher3.group(1);
        }

        return null;
    }

    /**
     * 解析线报消息，返回提取的信息
     * 
     * @param message 线报消息
     * @return 包含URLs和SKUIDs的Map
     */
    public static Map<String, Object> parseMessage(String message) {
        Map<String, Object> result = new HashMap<>();
        result.put("urls", extractJdUrls(message));
        result.put("skuids", extractSkuids(message));
        return result;
    }
}

