import random
import re

def random_swap_contiguous_v1(text: str, n_swaps: int = 1, max_retry: int = 10):
    """
    在字符串中随机选取连续的非标点、非数字中文字符片段，
    并在该片段内随机交换字符，同时记录修改区域的索引。
    若打乱后与原字符串相同，则重试，最多 max_retry 次。
    """
    chinese_spans = [(m.start(), m.end()) for m in re.finditer(r'[\u4e00-\u9fa5]+', text)]
    if not chinese_spans:
        return text, []

    text_list = list(text)
    modified_spans = []

    for _ in range(n_swaps):
        for attempt in range(max_retry):
            start, end = random.choice(chinese_spans)
            length = end - start
            if length < 2:
                continue

            sub_len = random.randint(2, min(5, length))  # [2,5]
            sub_start = random.randint(start, end - sub_len)
            sub_end = sub_start + sub_len

            before = ''.join(text_list[sub_start:sub_end])
            sub_chars = text_list[sub_start:sub_end]

            # 尝试打乱，直到不同
            shuffled = sub_chars[:]
            random.shuffle(shuffled)
            after = ''.join(shuffled)

            if after != before:
                text_list[sub_start:sub_end] = shuffled
                modified_spans.append({
                    "start": sub_start,
                    "end": sub_end,
                    "before": before,
                    "after": after
                })
                break  # 成功打乱后跳出 retry 循环
        else:
            print("⚠️ 无法有效打乱片段（内容重复），已跳过。")

    return ''.join(text_list), modified_spans

def random_swap_contiguous(text: str, n_swaps: int = 1, max_retry: int = 10):
    """
    在字符串中随机扰动连续片段：
    - 中文：在连续中文片段内打乱若干个连续汉字
    - 英文：在连续英文单词序列内打乱若干个连续单词
    打乱后记录修改区域索引和变化内容。
    """

    # 拆分文本为token，保留分隔符位置
    tokens = re.findall(r'[\u4e00-\u9fa5]+|[A-Za-z]+(?:\s+[A-Za-z]+)*|[^\u4e00-\u9fa5A-Za-z]+', text)

    text_list = list(text)
    modified_spans = []

    # 找出中文和英文片段（带索引范围）
    spans = []
    for m in re.finditer(r'[\u4e00-\u9fa5]+|([A-Za-z]+(?:\s+[A-Za-z]+)*)', text):
        start, end = m.span()
        spans.append((start, end, 'en' if m.group(1) else 'zh'))

    if not spans:
        return text, []

    for _ in range(n_swaps):
        for attempt in range(max_retry):
            start, end, lang = random.choice(spans)
            segment = text[start:end]

            if lang == 'zh':
                # 中文：随机扰动连续2~5个字符
                if len(segment) < 2:
                    continue
                sub_len = random.randint(2, min(5, len(segment)))
                sub_start = random.randint(0, len(segment) - sub_len)
                sub_end = sub_start + sub_len
                before = segment[sub_start:sub_end]
                sub_chars = list(before)
                random.shuffle(sub_chars)
                after = ''.join(sub_chars)
                if after == before:
                    continue
                new_segment = segment[:sub_start] + after + segment[sub_end:]
            else:
                # 英文：按单词打乱
                words = segment.split()
                if len(words) < 2:
                    continue
                sub_len = random.randint(2, min(4, len(words)))
                sub_start = random.randint(0, len(words) - sub_len)
                sub_end = sub_start + sub_len
                before = ' '.join(words[sub_start:sub_end])
                sub_words = words[sub_start:sub_end]
                random.shuffle(sub_words)
                after = ' '.join(sub_words)
                if after == before:
                    continue
                new_segment = ' '.join(words[:sub_start] + sub_words + words[sub_end:])

            # 替换文本
            text = text[:start] + new_segment + text[end:]
            modified_spans.append({
                "start": start,
                "end": end,
                "lang": lang,
                "before": segment,
                "after": new_segment
            })
            break
        else:
            print("⚠️ 无法有效打乱片段（内容重复），已跳过。")

    return text, modified_spans

if __name__ == "__main__":
    # 示例
    s = "需要在俄罗斯莫斯科和中国北京各转一次机，然后才能抵达西安，期间至少需要25个小时。"
    new_s, spans = random_swap_contiguous(s, n_swaps=1)

    print("原句：  ", s)
    print("打乱后：", new_s)
    print("修改记录：")
    for span in spans:
        print(span)