from __future__ import annotations

import hashlib
import html
import math
import re
import unicodedata
from dataclasses import asdict, dataclass


HANGUL_RE = re.compile(r"[가-힣]")
LATIN_RE = re.compile(r"[A-Za-z]")
CJK_RE = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff]")
URL_RE = re.compile(r"(?:https?://|www\.)\S+", re.IGNORECASE)
EMAIL_RE = re.compile(r"\b[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}\b")
PHONE_RE = re.compile(r"(?<!\d)(?:\+?82[- ]?)?0?1[016789][ -]?\d{3,4}[ -]?\d{4}(?!\d)")
RRN_RE = re.compile(r"(?<!\d)\d{6}[ -]?[1-4]\d{6}(?!\d)")
SCRIPT_STYLE_RE = re.compile(
    r"<(?:script|style)\b[^>]*>.*?</(?:script|style)>",
    re.IGNORECASE | re.DOTALL,
)
HTML_TAG_RE = re.compile(r"<[^>\n]{1,500}>")
MULTISPACE_RE = re.compile(r"[ \t]{2,}")
MANY_NEWLINES_RE = re.compile(r"\n{3,}")
CODE_LINE_RE = re.compile(
    r"^\s*(?:"
    r"(?:def|class|import|from|function|const|let|var|public|private)\s+"
    r"|#include\b|package\s+\w+|using\s+namespace\b"
    r"|[{}[\];]{2,}|</?\w+[^>]*>"
    r")"
)
CODE_MATH_CHARS = frozenset("{}[]<>=+*/\\^_|~`$")
WORD_RE = re.compile(r"[가-힣A-Za-z0-9]+")
LIST_LINE_RE = re.compile(
    r"^\s*(?:[-*•·▪◦▶▷■□]|(?:\d+|[가-힣A-Za-z])[.)])\s+"
)
BOILERPLATE_RE = re.compile(
    r"(?:로그인|회원가입|개인정보\s*처리방침|이용약관|전체\s*메뉴|"
    r"장바구니|상품\s*후기|배송\s*조회|쿠폰|고객\s*센터|"
    r"무단\s*전재|재배포\s*금지|관련\s*기사|실시간\s*뉴스)"
)
REPEATED_CHARACTER_RE = re.compile(r"(.)\1+")
NON_CONTENT_RE = re.compile(r"[\W_]+", re.UNICODE)


@dataclass(slots=True)
class FilterConfig:
    min_chars: int = 300
    max_chars: int = 100_000
    min_hangul_chars: int = 50
    min_hangul_letter_ratio: float = 0.70
    min_hangul_visible_ratio: float = 0.55
    max_digit_ratio: float = 0.08
    max_symbol_ratio: float = 0.15
    max_url_per_word: float = 0.01
    min_unique_line_ratio: float = 0.70
    min_unique_word_ratio: float = 0.20
    max_short_line_ratio: float = 0.50
    max_list_line_ratio: float = 0.25
    max_table_line_ratio: float = 0.10
    max_boilerplate_hits_per_1k: float = 1.5
    max_repeated_character_run: int = 20
    max_code_line_ratio: float = 0.25
    max_code_math_char_ratio: float = 0.15
    min_quality_score: float = 0.70
    strip_html: bool = True
    mask_pii: bool = True


@dataclass(slots=True)
class TextMetrics:
    characters: int
    visible_characters: int
    hangul_characters: int
    latin_characters: int
    cjk_characters: int
    digit_characters: int
    symbol_characters: int
    hangul_letter_ratio: float
    hangul_visible_ratio: float
    digit_ratio: float
    symbol_ratio: float
    url_per_word: float
    unique_line_ratio: float
    unique_word_ratio: float
    short_line_ratio: float
    list_line_ratio: float
    table_line_ratio: float
    boilerplate_hits_per_1k: float
    repeated_character_run: int
    code_line_ratio: float
    code_math_char_ratio: float

    def to_dict(self) -> dict[str, int | float]:
        return asdict(self)


def normalize_text(
    text: str,
    *,
    strip_html: bool = True,
    mask_pii: bool = True,
) -> str:
    if not isinstance(text, str):
        raise TypeError(f"text must be str, got {type(text).__name__}")

    text = unicodedata.normalize("NFC", text)
    text = text.replace("\r\n", "\n").replace("\r", "\n")
    text = text.replace("\u00a0", " ").replace("\u200b", "")
    text = text.replace("\u200c", "").replace("\u200d", "")
    text = "".join(
        character
        for character in text
        if character in "\n\t" or unicodedata.category(character) != "Cc"
    )

    if strip_html:
        text = SCRIPT_STYLE_RE.sub(" ", text)
        text = HTML_TAG_RE.sub(" ", text)
        text = html.unescape(text)

    if mask_pii:
        text = EMAIL_RE.sub("<EMAIL>", text)
        text = PHONE_RE.sub("<PHONE>", text)
        text = RRN_RE.sub("<RRN>", text)

    lines = [MULTISPACE_RE.sub(" ", line).strip() for line in text.splitlines()]
    text = "\n".join(line for line in lines if line)
    text = MANY_NEWLINES_RE.sub("\n\n", text)
    return text.strip()


def measure_text(text: str) -> TextMetrics:
    visible = [character for character in text if not character.isspace()]
    hangul_count = len(HANGUL_RE.findall(text))
    latin_count = len(LATIN_RE.findall(text))
    cjk_count = len(CJK_RE.findall(text))
    digit_count = sum(character.isdigit() for character in visible)
    symbol_count = sum(
        unicodedata.category(character).startswith(("P", "S"))
        for character in visible
    )
    letter_count = hangul_count + latin_count + cjk_count
    lines = [line for line in text.splitlines() if line.strip()]
    words = text.split()
    content_words = WORD_RE.findall(text.casefold())
    code_lines = sum(bool(CODE_LINE_RE.search(line)) for line in lines)
    code_math_count = sum(character in CODE_MATH_CHARS for character in visible)
    short_lines = sum(len(line.strip()) < 20 for line in lines)
    list_lines = sum(bool(LIST_LINE_RE.search(line)) for line in lines)
    table_lines = sum(line.count("|") >= 2 for line in lines)
    boilerplate_hits = len(BOILERPLATE_RE.findall(text))
    repeated_runs = [
        len(match.group(0)) for match in REPEATED_CHARACTER_RE.finditer(text)
    ]

    return TextMetrics(
        characters=len(text),
        visible_characters=len(visible),
        hangul_characters=hangul_count,
        latin_characters=latin_count,
        cjk_characters=cjk_count,
        digit_characters=digit_count,
        symbol_characters=symbol_count,
        hangul_letter_ratio=hangul_count / max(letter_count, 1),
        hangul_visible_ratio=hangul_count / max(len(visible), 1),
        digit_ratio=digit_count / max(len(visible), 1),
        symbol_ratio=symbol_count / max(len(visible), 1),
        url_per_word=len(URL_RE.findall(text)) / max(len(words), 1),
        unique_line_ratio=len(set(lines)) / max(len(lines), 1),
        unique_word_ratio=len(set(content_words)) / max(len(content_words), 1),
        short_line_ratio=short_lines / max(len(lines), 1),
        list_line_ratio=list_lines / max(len(lines), 1),
        table_line_ratio=table_lines / max(len(lines), 1),
        boilerplate_hits_per_1k=boilerplate_hits * 1000 / max(len(text), 1),
        repeated_character_run=max(repeated_runs, default=1),
        code_line_ratio=code_lines / max(len(lines), 1),
        code_math_char_ratio=code_math_count / max(len(visible), 1),
    )


def rejection_reason(
    text: str,
    config: FilterConfig,
    *,
    metrics: TextMetrics | None = None,
) -> str | None:
    metrics = metrics or measure_text(text)
    if metrics.characters < config.min_chars:
        return "too_short"
    if metrics.characters > config.max_chars:
        return "too_long"
    if metrics.hangul_characters < config.min_hangul_chars:
        return "too_little_hangul"
    if metrics.hangul_letter_ratio < config.min_hangul_letter_ratio:
        return "low_hangul_letter_ratio"
    if metrics.hangul_visible_ratio < config.min_hangul_visible_ratio:
        return "low_hangul_visible_ratio"
    if metrics.digit_ratio > config.max_digit_ratio:
        return "digit_heavy"
    if metrics.symbol_ratio > config.max_symbol_ratio:
        return "symbol_heavy"
    if metrics.repeated_character_run > config.max_repeated_character_run:
        return "repeated_character_run"
    if metrics.url_per_word > config.max_url_per_word:
        return "too_many_urls"
    if (
        len(text.splitlines()) >= 5
        and metrics.unique_line_ratio < config.min_unique_line_ratio
    ):
        return "repeated_lines"
    if len(WORD_RE.findall(text)) >= 100 and (
        metrics.unique_word_ratio < config.min_unique_word_ratio
    ):
        return "low_unique_word_ratio"
    if (
        len(text.splitlines()) >= 8
        and metrics.short_line_ratio > config.max_short_line_ratio
    ):
        return "short_line_heavy"
    if (
        len(text.splitlines()) >= 8
        and metrics.list_line_ratio > config.max_list_line_ratio
    ):
        return "list_heavy"
    if (
        len(text.splitlines()) >= 4
        and metrics.table_line_ratio > config.max_table_line_ratio
    ):
        return "table_heavy"
    if metrics.boilerplate_hits_per_1k > config.max_boilerplate_hits_per_1k:
        return "boilerplate_heavy"
    if (
        len(text.splitlines()) >= 4
        and metrics.code_line_ratio > config.max_code_line_ratio
    ):
        return "code_heavy"
    if metrics.code_math_char_ratio > config.max_code_math_char_ratio:
        return "code_or_math_heavy"
    if quality_score(metrics, config) < config.min_quality_score:
        return "low_quality_score"
    return None


def quality_score(metrics: TextMetrics, config: FilterConfig) -> float:
    """Return a conservative 0..1 heuristic used for corpus auditing."""
    hangul_score = min(
        1.0,
        metrics.hangul_visible_ratio
        / max(config.min_hangul_visible_ratio * 1.5, 1e-9),
    )
    digit_score = max(
        0.0,
        1.0
        - metrics.digit_ratio / max(config.max_digit_ratio * 2.0, 1e-9),
    )
    symbol_score = max(
        0.0,
        1.0
        - metrics.symbol_ratio / max(config.max_symbol_ratio * 2.0, 1e-9),
    )
    line_score = min(1.0, metrics.unique_line_ratio)
    word_score = min(1.0, metrics.unique_word_ratio / 0.50)
    score = (
        0.35 * hangul_score
        + 0.20 * digit_score
        + 0.15 * symbol_score
        + 0.15 * line_score
        + 0.15 * word_score
    )
    return max(0.0, min(1.0, score))


def near_duplicate_signature(text: str, *, sketch_size: int = 4) -> str:
    """Build a bottom-k paragraph/chunk sketch for conservative near deduplication."""
    if sketch_size <= 0:
        raise ValueError("sketch_size must be positive")

    canonical_blocks: list[str] = []
    for paragraph in re.split(r"\n+", text):
        canonical = NON_CONTENT_RE.sub("", paragraph.casefold())
        if len(canonical) < 40:
            continue
        if len(canonical) <= 320:
            canonical_blocks.append(canonical)
            continue
        for start in range(0, len(canonical), 240):
            chunk = canonical[start : start + 320]
            if len(chunk) >= 80:
                canonical_blocks.append(chunk)

    if not canonical_blocks:
        canonical = NON_CONTENT_RE.sub("", text.casefold())
        canonical_blocks = [
            canonical[start : start + 320]
            for start in range(0, len(canonical), 240)
            if len(canonical[start : start + 320]) >= 40
        ]

    fingerprints = sorted(
        {
            hashlib.blake2b(
                block.encode("utf-8"), digest_size=8, person=b"kawk-v2"
            ).hexdigest()
            for block in canonical_blocks
        }
    )
    length_bucket = int(math.log2(max(len(text), 1)) * 4)
    selected = fingerprints[:sketch_size]
    return f"{length_bucket}:" + ":".join(selected)


def canonical_hash(text: str) -> str:
    canonical = " ".join(text.casefold().split())
    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()


def split_for_hash(
    document_hash: str,
    *,
    validation_ratio: float,
    test_ratio: float,
    seed: int,
) -> str:
    if validation_ratio < 0 or test_ratio < 0:
        raise ValueError("split ratios must be non-negative")
    if validation_ratio + test_ratio >= 1:
        raise ValueError("validation_ratio + test_ratio must be less than 1")
    digest = hashlib.blake2b(
        f"{seed}:{document_hash}".encode("ascii"), digest_size=8
    ).digest()
    value = int.from_bytes(digest, "big") / 2**64
    if value < test_ratio:
        return "test"
    if value < test_ratio + validation_ratio:
        return "validation"
    return "train"