import difflib
import unicodedata
import re
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Tuple, NamedTuple

class MatchStatus(Enum):
    """匹配状态"""
    EXACT = "精确匹配"
    FUZZY = "模糊匹配"
    NOT_FOUND = "未找到"

@dataclass
class SpanMatch:
    """quote和原文匹配的结果"""
    quote: str
    start: Optional[int]
    end: Optional[int]
    score: float
    status: MatchStatus

class MatchResult(NamedTuple):
    start: Optional[int]
    end: Optional[int]
    score: float

class TextNormalizer:
    """文本标准化, 保证匹配稳定"""
    @staticmethod
    def normalize(text: str) -> str:
        if not text:
            return ""
        text = unicodedata.normalize("NFC", text)
        text = re.sub(r"\s+", " ", text).strip()
        return text

    @staticmethod
    def create_index_map(original: str, normalized: str) -> List[int]:
        index_map = []
        orig_idx = 0
        for norm_char in normalized:
            while orig_idx < len(original) and original[orig_idx].isspace() and norm_char != ' ':
                orig_idx += 1
            if orig_idx < len(original):
                index_map.append(orig_idx)
                orig_idx += 1
            else:
                index_map.append(len(original))
        return index_map

class MatchingConfig:
    """匹配配置参数"""
    def __init__(
        self,
        threshold: float = 0.85,
        exact_threshold: float = 0.999,
        min_step_size: int = 8,
        step_fraction: int = 4,
        window_padding: int = 64
    ):
        self.threshold = threshold
        self.exact_threshold = exact_threshold
        self.min_step_size = min_step_size
        self.step_fraction = step_fraction
        self.window_padding = window_padding

    def get_step_size(self, quote_length: int) -> int:
        return max(self.min_step_size, quote_length // self.step_fraction)

    def get_window_size(self, quote_length: int) -> int:
        return quote_length + self.window_padding

class ExactMatcher:
    """精确匹配"""
    @staticmethod
    def find_exact_match(text: str, quote: str) -> MatchResult:
        start = text.find(quote)
        if start != -1:
            return MatchResult(start, start + len(quote), 1.0)
        return MatchResult(None, None, 0.0)

class FuzzyMatcher:
    """模糊匹配 (difflib实现) """
    def __init__(self, config: MatchingConfig):
        self.config = config

    def find_fuzzy_match(self, text: str, quote: str) -> MatchResult:
        if not quote or not text:
            return MatchResult(None, None, 0.0)
        best_match = MatchResult(None, None, 0.0)
        quote_len = len(quote)
        step_size = self.config.get_step_size(quote_len)
        window_size = self.config.get_window_size(quote_len)
        for i in range(0, max(1, len(text) - quote_len + 1), step_size):
            window = text[i:i + window_size]
            match_result = self._match_in_window(quote, window, i)
            if match_result.score > best_match.score:
                best_match = match_result
        if best_match.score >= self.config.threshold:
            return best_match
        return MatchResult(None, None, best_match.score)

    def _match_in_window(self, quote: str, window: str, window_start: int) -> MatchResult:
        matcher = difflib.SequenceMatcher(a=quote, b=window, autojunk=False)
        score = matcher.ratio()
        if score <= 0:
            return MatchResult(None, None, score)
        blocks = matcher.get_matching_blocks()
        if not blocks:
            return MatchResult(None, None, score)
        main_block = max(blocks[:-1], key=lambda b: b.size, default=blocks[0])
        match_start = window_start + main_block.b - main_block.a
        match_start = max(0, match_start)
        match_end = match_start + len(quote)
        return MatchResult(match_start, match_end, score)

class QuoteAligner:
    """主流程协调器"""
    def __init__(self, config: Optional[MatchingConfig] = None):
        self.config = config or MatchingConfig()
        self.normalizer = TextNormalizer()
        self.exact_matcher = ExactMatcher()
        self.fuzzy_matcher = FuzzyMatcher(self.config)

    def align_quote(self, source_text: str, quote: str) -> SpanMatch:
        if not quote or not source_text:
            return SpanMatch(quote, None, None, 0.0, MatchStatus.NOT_FOUND)
        norm_source = self.normalizer.normalize(source_text)
        norm_quote = self.normalizer.normalize(quote)
        exact_result = self.exact_matcher.find_exact_match(norm_source, norm_quote)
        if exact_result.start is not None:
            return SpanMatch(
                quote=quote,
                start=exact_result.start,
                end=exact_result.end,
                score=exact_result.score,
                status=MatchStatus.EXACT
            )
        fuzzy_result = self.fuzzy_matcher.find_fuzzy_match(norm_source, norm_quote)
        if fuzzy_result.start is not None:
            status = (MatchStatus.EXACT if fuzzy_result.score >= self.config.exact_threshold
                     else MatchStatus.FUZZY)
            return SpanMatch(
                quote=quote,
                start=fuzzy_result.start,
                end=fuzzy_result.end,
                score=fuzzy_result.score,
                status=status
            )
        return SpanMatch(
            quote=quote,
            start=None,
            end=None,
            score=fuzzy_result.score,
            status=MatchStatus.NOT_FOUND
        )

    def align_quotes(self, source_text: str, quotes: List[str]) -> List[SpanMatch]:
        return [self.align_quote(source_text, quote) for quote in quotes]

def align_quotes(source_text: str, quotes: List[str], threshold: float = 0.85) -> List[SpanMatch]:
    config = MatchingConfig(threshold=threshold)
    aligner = QuoteAligner(config)
    return aligner.align_quotes(source_text, quotes)

# 示例用法
if __name__ == "__main__":
    source = "Nintendo can set the price unchallenged in their market segment."
    quotes = [
        "Nintendo can set the price unchallenged",  # 精确匹配
        "Nintendo can set prices without competition",  # 模糊匹配
        "Sony dominates the market"  # 完全没戏
    ]
    results = align_quotes(source, quotes, threshold=0.8)
    for result in results:
        print(f"Quote: '{result.quote}'")
        print(f"Status: {result.status.value}")
        print(f"Score: {result.score:.3f}")
        if result.start is not None:
            print(f"Position: [{result.start}:{result.end}]")
            print(f"Found: '{source[result.start:result.end]}'")
        print("-" * 50)

# 想快速对齐quote?一句话搞定
results = align_quotes(source_text, quotes, threshold=0.8)

# 想精细调参?用全套API
config = MatchingConfig(threshold=0.9, window_padding=128)
aligner = QuoteAligner(config)
results = aligner.align_quotes(source_text, quotes)