"""Deterministic hard-gate validators for generated resumes.

The validators in this module deliberately operate on the typed intermediate
representation instead of rendered Markdown.  They are conservative where a
regular expression could otherwise confuse a technology term with personal
data, and they never include a detected PII value in a finding message.
"""

from __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from datetime import datetime, timezone
from decimal import Decimal, InvalidOperation
import re
import unicodedata

from .models import (
    CandidateProfile,
    ConstraintKind,
    DraftClaim,
    EvidenceItem,
    GenerationConfig,
    JobAnalysis,
    PostingConstraint,
    QualityCategory,
    QualityFinding,
    QualitySeverity,
    ResumeDraft,
    ResumeMode,
    SectionType,
    SensitiveDataCategory,
    _claim_mentions_requirement,
)


_RESIDENT_ID_PATTERN = re.compile(
    r"(?<!\d)\d{6}\s*[-\u2013\u2014]\s*[1-8]\d{6}(?!\d)"
)
_EMAIL_PATTERN = re.compile(
    r"(?<![\w.+-])[A-Z0-9.!#$%&'*+/=?^_`{|}~-]+@"
    r"(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+"
    r"[A-Z]{2,63}(?![\w.-])",
    re.IGNORECASE,
)
_PHONE_PATTERN = re.compile(
    r"(?<!\d)"
    r"(?:(?:\+|00)82[\s.-]?)?"
    r"(?:0?(?:1[016789]|2|3[1-3]|4[1-4]|5[1-5]|6[1-4]|70))"
    r"[\s.)-]?\d{3,4}[\s.-]?\d{4}"
    r"(?!\d)"
)
_BANK_ACCOUNT_PATTERN = re.compile(
    r"(?:계좌(?:\s*번호)?|은행\s*계좌)\s*[:\uff1a]?\s*\d[\d\s-]{7,}\d"
)
_PLACEHOLDER_PATTERNS = (
    re.compile(r"(?<![A-Z])TBD(?![A-Z])", re.IGNORECASE),
    re.compile(r"(?:[\[({<\u3010]\s*)?확인\s*필요(?:\s*[\])}>\u3011])?(?![가-힣])"),
)

# Numeric identifiers containing ASCII letters (B2B, OAuth2, HTTP/2, EC2,
# ISO-27001) are not quantitative claims.  Keeping them out of the number
# validator avoids a common and costly false positive.
_NUMBER_PATTERN = re.compile(
    r"(?<![A-Za-z0-9_])"
    r"[+-]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?"
    r"(?![0-9_])"
)
_IDENTIFIER_CHARS = frozenset(
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_./:+-"
)
_NUMBER_UNIT_PATTERN = re.compile(
    r"\s*(%|퍼센트|milliseconds?|ms|seconds?|secs?|s|명|건|개|회|배|"
    r"개월|년|월|일|시간|분|초|억원|만원|원|TB|GB|MB|KB)",
    re.IGNORECASE,
)
_ASCII_NUMBER_WITH_UNIT_PATTERN = re.compile(
    r"^[+-]?[\d,.]+(?:milliseconds?|ms|seconds?|secs?|s|TB|GB|MB|KB)$",
    re.IGNORECASE,
)
_RATIO_METRIC_KEY_PATTERN = re.compile(
    r"(?:rate|ratio|percent|percentage|pct|reduction|increase|decrease|"
    r"improvement|률|율|비율|증가|감소|개선)",
    re.IGNORECASE,
)
_NUMERIC_DATE_RANGE_PATTERN = re.compile(
    r"(?<!\d)(?P<sy>(?:19|20)\d{2})[./-](?P<sm>\d{1,2})"
    r"(?:[./-](?P<sd>\d{1,2}))?\s*"
    r"(?:~|\u2013|\u2014|\u301c|\uFF5E|부터)\s*"
    r"(?P<ey>(?:19|20)\d{2})[./-](?P<em>\d{1,2})"
    r"(?:[./-](?P<ed>\d{1,2}))?(?:까지)?(?!\d)"
)


# These patterns require an explicit label, value, or first-person construction.
# Bare words such as "사진" and "장애" are intentionally absent because they
# frequently describe legitimate engineering work.
_SENSITIVE_PATTERNS: tuple[
    tuple[SensitiveDataCategory, tuple[re.Pattern[str], ...]], ...
] = (
    (
        SensitiveDataCategory.PHOTO,
        (
            re.compile(r"(?:증명|반명함|여권|프로필)\s*사진"),
            re.compile(r"사진\s*(?:첨부|부착|제출)"),
        ),
    ),
    (
        SensitiveDataCategory.BIRTH_DATE,
        (
            re.compile(r"(?:생년월일|출생(?:일|연월일)?)\s*[:\uff1a]?"),
            re.compile(
                r"(?<!\d)(?:19|20)\d{2}\s*년\s*\d{1,2}\s*월\s*"
                r"\d{1,2}\s*일\s*(?:생|출생)(?![가-힣])"
            ),
            re.compile(r"(?<!\d)(?:19|20)\d{2}\s*년생(?![가-힣])"),
        ),
    ),
    (
        SensitiveDataCategory.GENDER,
        (
            re.compile(r"성별\s*[:\uff1a]\s*(?:남(?:성)?|여(?:성)?)(?![가-힣])"),
            re.compile(r"저는\s*(?:남성|여성)(?:입니다|이고|이며)"),
        ),
    ),
    (
        SensitiveDataCategory.FULL_ADDRESS,
        (
            re.compile(r"(?:상세\s*)?주소\s*[:\uff1a]\s*\S+"),
            re.compile(r"거주지\s*[:\uff1a]\s*\S+"),
        ),
    ),
    (
        SensitiveDataCategory.MARITAL_STATUS,
        (
            re.compile(r"혼인\s*여부"),
            re.compile(r"결혼\s*여부"),
            re.compile(r"(?:기혼|미혼)(?:입니다|\s|[,.)]|$)"),
        ),
    ),
    (
        SensitiveDataCategory.FAMILY_DETAILS,
        (
            re.compile(r"가족\s*관계"),
            re.compile(r"(?:부친|모친|배우자|자녀)\s*[:\uff1a]"),
            re.compile(r"(?:아버지|어머니|부모님)(?:의|은|는|이|가|께서)"),
        ),
    ),
    (
        SensitiveDataCategory.RELIGION,
        (
            re.compile(r"종교\s*[:\uff1a]\s*\S+"),
            re.compile(r"저의?\s*신앙은?\s*\S+"),
        ),
    ),
    (
        SensitiveDataCategory.DISABILITY,
        (
            re.compile(r"장애\s*(?:여부|등급|유형)\s*[:\uff1a]?"),
            re.compile(r"장애인\s*등록\s*(?:여부|번호)"),
        ),
    ),
    (
        SensitiveDataCategory.HEALTH,
        (
            re.compile(r"혈액형\s*[:\uff1a]\s*(?:A|B|AB|O)[+-]?\s*형?", re.IGNORECASE),
            re.compile(r"(?:신장|키|체중)\s*[:\uff1a]\s*\d"),
            re.compile(r"건강\s*상태\s*[:\uff1a]"),
        ),
    ),
    (
        SensitiveDataCategory.MILITARY_DETAILS,
        (
            re.compile(r"병역\s*(?:사항|구분|여부|상태)?\s*[:\uff1a]"),
            re.compile(r"(?:군필|미필|병역\s*면제)(?:입니다|\s|[,.)]|$)"),
        ),
    ),
    (
        SensitiveDataCategory.COMPENSATION,
        (
            re.compile(r"(?:현재|희망)?\s*연봉\s*[:\uff1a]\s*\d"),
            re.compile(r"(?:현재|희망)\s*급여\s*[:\uff1a]\s*\d"),
        ),
    ),
    (
        SensitiveDataCategory.POLITICAL_OPINION,
        (
            re.compile(
                r"(?:정치적\s*견해|지지\s*정당|정당\s*가입\s*여부)\s*[:：]?"
            ),
            re.compile(r"저는\s*\S+당을\s*지지합니다"),
        ),
    ),
    (
        SensitiveDataCategory.PROPERTY,
        (
            re.compile(
                r"(?:재산\s*(?:총액|보유액|내역)?|보유\s*부동산|자산\s*총액)"
                r"\s*[:：]\s*\S+"
            ),
        ),
    ),
    (
        SensitiveDataCategory.BANK_ACCOUNT,
        (_BANK_ACCOUNT_PATTERN,),
    ),
)

_BLIND_SCHOOL_PATTERNS = (
    re.compile(r"(?:학교명|출신\s*학교)\s*[:\uff1a]?"),
    re.compile(
        r"(?<![가-힣A-Za-z0-9])"
        r"[가-힣A-Za-z0-9\u00b7]{2,}(?:대학교|고등학교|중학교)"
        r"(?=에서|의|를|은|는|이|가|졸업|재학|수료|[\s,.)]|$)"
    ),
    # Korean university abbreviations are routinely written as ``서울대`` or
    # ``연세대``.  Requiring education context avoids treating ordinary words
    # such as ``최대`` as institutions while still catching natural prose such
    # as ``서울대에서 전공`` and ``고대 출신``.
    re.compile(
        r"(?<![가-힣A-Za-z0-9])"
        r"(?!최대|상대|절대|확대|세대|일대|휴대|군대|근대|현대)"
        r"[가-힣]{1,8}대"
        r"(?=에서|의|를|은|는|이|가|출신|졸업|재학|수료|전공|[\s,.)]|$)"
    ),
    re.compile(
        r"(?<![A-Za-z0-9])(?:SNU|KAIST|POSTECH|UNIST|GIST|DGIST)"
        r"(?=에서|의|를|은|는|이|가|출신|졸업|재학|수료|전공|[\s,.)]|$)",
        re.IGNORECASE,
    ),
)
_BLIND_ORIGIN_PATTERNS = (
    # Explicit origin labels are sensitive even when the following region is
    # not in a finite city-name dictionary.  Requiring a label delimiter or a
    # Korean topic/nominative particle avoids matching ordinary compounds such
    # as ``고향사랑기부제`` and job-relevant phrases such as ``지역 고객``.
    re.compile(
        r"(?:출신\s*(?:지역|지)|고향)\s*"
        r"(?:[:\uff1a=]|은|는|이|가)(?=\s*\S)"
    ),
    # Colloquial profile text often omits both the label delimiter and topic
    # particle (``고향 대전``).  It is still an explicit place-of-origin
    # disclosure.  Exclude the common ``고향 사랑`` policy phrase so that a
    # job-related public-service project does not become a false positive.
    re.compile(
        r"(?:출신\s*(?:지역|지)|고향)\s+"
        r"(?!(?:사랑|기부|정책|문화|서비스)(?=[\s,.)]|$))"
        r"[가-힣]{2,20}(?=[\s,.)]|$)"
    ),
    re.compile(
        r"(?:서울|부산|대구|인천|광주|대전|울산|세종|제주|"
        r"[가-힣]{2,}(?:시|도|군|구))\s*출신"
        r"(?:입니다|이고|이며|으로|자|[\s,.]|$)"
    ),
    re.compile(
        r"(?:서울|부산|대구|인천|광주|대전|울산|세종|제주|"
        r"[가-힣]{2,}(?:시|도|군|구))에서\s*"
        r"(?:태어나|태어났|출생|성장|자라|자랐)"
    ),
)
_BLIND_IDENTITY_PATTERN = re.compile(
    r"(?:이름|성명)\s*[:\uff1a]\s*"
    r"[가-힣A-Za-z](?:\s*[가-힣A-Za-z]){1,39}(?![가-힣A-Za-z])"
)
_TECH_TERM_PATTERN = re.compile(
    r"(?<![A-Za-z0-9_])"
    r"[A-Za-z][A-Za-z0-9]*(?:[.+#/-][A-Za-z0-9]+)*"
    r"(?![A-Za-z0-9_])"
)
_TECH_TERM_STOPWORDS = frozenset(
    {
        "a",
        "an",
        "and",
        "as",
        "at",
        "by",
        "for",
        "from",
        "in",
        "of",
        "on",
        "or",
        "the",
        "to",
        "using",
        "via",
        "with",
    }
)
_KOREAN_TECH_TERMS = (
    "쿠버네티스",
    "카프카",
    "도커",
    "레디스",
    "리액트",
    "스프링",
    "장고",
    "플라스크",
    "젠킨스",
    "테라폼",
    "그라파나",
    "프로메테우스",
)
_HIGH_RISK_KOREAN_CLAIM_TERMS = (
    "대규모",
    "글로벌",
    "전사",
    "총괄",
    "아키텍처",
    "분산 시스템",
    "최초",
    "유일",
    "최고",
    "전문가",
    "책임자",
    "팀장",
    "수상",
    "우승",
    "최우수상",
    "대통령상",
    "승진",
    "특허",
    "논문",
    "자격증",
    "공인 인증",
    "매출",
    "투자 유치",
)
_GROUNDING_STOPWORDS = frozenset(
    {
        "경험",
        "업무",
        "담당",
        "관련",
        "기반",
        "통해",
        "위해",
        "대한",
        "사용",
        "활용",
        "수행",
        "진행",
        "참여",
        "과정",
        "결과",
        "역할",
        "있습니다",
        "했습니다",
        "합니다",
        "하였다",
        "했다",
        "있는",
        "그리고",
        "또한",
        "대한",
    }
)
_KOREAN_GROUNDING_TOKEN_PATTERN = re.compile(r"[가-힣]{2,}")
_BLIND_AGE_PATTERNS = (
    re.compile(r"나이\s*[:\uff1a]\s*(?:만\s*)?\d{1,3}\s*세?"),
    re.compile(r"만\s*\d{1,3}\s*세(?:입니다|이고|이며|[\s,.]|$)"),
)
_EMPLOYER_NAME_PATTERNS = (
    re.compile(
        r"(?:회사명|기업명|기관명|근무\s*기관|근무처|직장명)"
        r"\s*[:\uff1a]\s*\S+"
    ),
    re.compile(
        r"(?<![가-힣A-Za-z0-9])"
        r"[가-힣A-Za-z0-9\u00b7]{2,}\s*"
        r"(?:주식회사|유한회사|공사|공단|재단|병원)"
        r"(?=에서|의|를|은|는|이|가|[\s,.)]|$)"
    ),
)
_EMPLOYER_FIELD_KEYWORDS = (
    "회사명",
    "기업명",
    "기관명",
    "근무기관",
    "근무처",
    "직장명",
)
_GENERIC_LOCATION_CONTEXT = (
    "프로젝트",
    "팀",
    "환경",
    "업무",
    "과정",
    "서비스",
    "시스템",
    "현장",
    "조직",
    "회사",
    "기관",
    "지역",
    "애플리케이션",
    "플랫폼",
    "데이터베이스",
    "클라우드",
    "백엔드",
    "프론트엔드",
    "코드베이스",
    "저장소",
    "브라우저",
    "서버",
    "클라이언트",
    "네트워크",
    "컨테이너",
    "파이프라인",
    "Python",
    "Java",
    "Kotlin",
    "AWS",
    "GCP",
    "Azure",
    "Linux",
    "Kubernetes",
    "Docker",
    "서울",
    "부산",
    "대전",
    "대구",
    "광주",
    "인천",
)

_CONSTRAINT_CATEGORY_KEYWORDS: tuple[
    tuple[SensitiveDataCategory, tuple[str, ...]], ...
] = (
    (SensitiveDataCategory.PHOTO, ("사진", "외모")),
    (SensitiveDataCategory.BIRTH_DATE, ("생년월일", "생일", "출생")),
    (SensitiveDataCategory.GENDER, ("성별", "성별정보")),
    (SensitiveDataCategory.FULL_ADDRESS, ("주소", "거주지")),
    (SensitiveDataCategory.MARITAL_STATUS, ("혼인", "결혼")),
    (SensitiveDataCategory.FAMILY_DETAILS, ("가족", "부모", "배우자", "자녀")),
    (SensitiveDataCategory.RELIGION, ("종교", "신앙")),
    (SensitiveDataCategory.DISABILITY, ("장애",)),
    (SensitiveDataCategory.HEALTH, ("건강", "혈액형", "신장", "체중")),
    (SensitiveDataCategory.MILITARY_DETAILS, ("병역", "군필", "미필")),
    (SensitiveDataCategory.COMPENSATION, ("연봉", "급여")),
    (
        SensitiveDataCategory.POLITICAL_OPINION,
        ("정치적견해", "지지정당", "정당가입"),
    ),
    (SensitiveDataCategory.PROPERTY, ("재산", "부동산", "자산총액")),
    (SensitiveDataCategory.BANK_ACCOUNT, ("계좌",)),
)


@dataclass(frozen=True)
class _TextTarget:
    text: str
    location: str
    claim: DraftClaim | None = None

    @property
    def claim_id(self) -> str | None:
        return self.claim.claim_id if self.claim is not None else None

    @property
    def evidence_ids(self) -> list[str]:
        return list(self.claim.evidence_ids) if self.claim is not None else []


@dataclass(frozen=True)
class _NumericToken:
    value: Decimal
    display: str
    is_percent: bool
    unit: str | None


class _FindingCollector:
    def __init__(self) -> None:
        self.findings: list[QualityFinding] = []

    def add(
        self,
        *,
        code: str,
        severity: QualitySeverity,
        category: QualityCategory,
        message: str,
        location: str | None = None,
        claim_id: str | None = None,
        evidence_ids: Iterable[str] = (),
        suggestion: str | None = None,
    ) -> None:
        unique_evidence = list(dict.fromkeys(evidence_ids))
        self.findings.append(
            QualityFinding(
                finding_id=f"deterministic-{len(self.findings) + 1:04d}",
                code=code,
                severity=severity,
                category=category,
                message=message,
                location=location,
                claim_id=claim_id,
                evidence_ids=unique_evidence,
                suggestion=suggestion,
            )
        )


def _normalise_claim_text(text: str) -> str:
    normalised = unicodedata.normalize("NFKC", text).casefold()
    normalised = re.sub(r"\s+", " ", normalised).strip()
    normalised = re.sub(r"^[\-*•·]\s*", "", normalised)
    return normalised.rstrip(".!?。 ")


def _candidate_identity_patterns(profile: CandidateProfile) -> tuple[re.Pattern[str], ...]:
    patterns: list[re.Pattern[str]] = [_BLIND_IDENTITY_PATTERN]
    for name in (profile.name, profile.name_en):
        if not name:
            continue
        escaped = re.escape(name)
        if re.search(r"[가-힣]", name):
            compact_name = re.sub(r"\s+", "", name)
            flexible_name = r"\s*".join(
                re.escape(character) for character in compact_name
            )
            patterns.append(
                re.compile(
                    rf"(?<![가-힣A-Za-z0-9]){flexible_name}"
                    rf"(?=(?:은|는|이|가|을|를|의|에게|께서|으로|입니다|이라고|"
                    rf"[\s,.)]|$))",
                    re.IGNORECASE,
                )
            )
        else:
            patterns.append(
                re.compile(rf"(?<!\w){escaped}(?!\w)", re.IGNORECASE)
            )
    return tuple(patterns)


def _unsupported_technical_terms(
    claim: DraftClaim, supporting_facts: Iterable[EvidenceItem]
) -> list[str]:
    facts = tuple(supporting_facts)
    evidence_text = " ".join(
        [
            part
            for fact in facts
            for part in (
                fact.content,
                " ".join(fact.keywords),
                " ".join(str(key) for key in fact.metrics),
                " ".join(str(value) for value in fact.metrics.values()),
            )
        ]
    ).casefold()
    evidence_tokens = {
        token.casefold() for token in _TECH_TERM_PATTERN.findall(evidence_text)
    }

    unsupported: list[str] = []
    for token in _TECH_TERM_PATTERN.findall(claim.text):
        folded = token.casefold()
        if folded in _TECH_TERM_STOPWORDS:
            continue
        if folded in evidence_tokens:
            continue
        if folded == "api" and any(known.endswith("api") for known in evidence_tokens):
            continue
        if folded in {"ci", "cd"} and any(
            known in {"ci/cd", "ci-cd"} for known in evidence_tokens
        ):
            continue
        unsupported.append(token)
    for term in _KOREAN_TECH_TERMS:
        if term in claim.text and term.casefold() not in evidence_text:
            unsupported.append(term)
    for term in _HIGH_RISK_KOREAN_CLAIM_TERMS:
        if term in claim.text and term.casefold() not in evidence_text:
            unsupported.append(term)
    return list(dict.fromkeys(unsupported))


def _grounding_tokens(text: str) -> set[str]:
    normalised = unicodedata.normalize("NFKC", text).casefold()
    tokens = {
        token.casefold()
        for token in _TECH_TERM_PATTERN.findall(normalised)
        if token.casefold() not in _TECH_TERM_STOPWORDS
    }
    tokens.update(
        token
        for token in _KOREAN_GROUNDING_TOKEN_PATTERN.findall(normalised)
        if token not in _GROUNDING_STOPWORDS
    )
    return tokens


def _korean_common_prefix(left: str, right: str) -> int:
    length = 0
    for left_char, right_char in zip(left, right):
        if left_char != right_char:
            break
        length += 1
    return length


def _token_is_supported(token: str, evidence_tokens: set[str]) -> bool:
    if token in evidence_tokens:
        return True
    if re.fullmatch(r"[가-힣]+", token):
        return any(
            re.fullmatch(r"[가-힣]+", candidate) is not None
            and (
                (min(len(token), len(candidate)) >= 3 and (
                    token in candidate or candidate in token
                ))
                or _korean_common_prefix(token, candidate) >= 2
            )
            for candidate in evidence_tokens
        )
    return False


def _low_lexical_support(
    claim: DraftClaim, supporting_facts: Iterable[EvidenceItem]
) -> tuple[bool, list[str]]:
    claim_tokens = _grounding_tokens(claim.text)
    if len(claim_tokens) < 2:
        return False, []
    evidence_text = " ".join(
        part
        for fact in supporting_facts
        for part in (
            fact.content,
            " ".join(fact.keywords),
            " ".join(str(key) for key in fact.metrics),
            " ".join(str(value) for value in fact.metrics.values()),
        )
    )
    evidence_tokens = _grounding_tokens(evidence_text)
    unsupported = sorted(
        token
        for token in claim_tokens
        if not _token_is_supported(token, evidence_tokens)
    )
    # A mostly grounded sentence can still append one wholly invented clause
    # (for example an award or leadership result).  Ratios therefore create a
    # dilution bypass: enough copied evidence hides two unsupported concepts.
    # In strict-evidence mode two unsupported semantic tokens are sufficient to
    # require repair, regardless of how much grounded text surrounds them.
    return len(unsupported) >= 2, unsupported


def _looks_like_hidden_fact_echo(claim_text: str, fact_text: str) -> bool:
    claim_normalised = _normalise_claim_text(claim_text)
    fact_normalised = _normalise_claim_text(fact_text)
    if min(len(claim_normalised), len(fact_normalised)) >= 12 and (
        claim_normalised in fact_normalised or fact_normalised in claim_normalised
    ):
        return True
    claim_tokens = _grounding_tokens(claim_text)
    fact_tokens = _grounding_tokens(fact_text)
    smaller = min(len(claim_tokens), len(fact_tokens))
    return smaller >= 3 and len(claim_tokens & fact_tokens) / smaller >= 0.7


def _has_match(patterns: Iterable[re.Pattern[str]], text: str) -> bool:
    return any(pattern.search(text) is not None for pattern in patterns)


def contains_public_blind_origin(text: str) -> bool:
    """Return whether *text* explicitly discloses a person's place of origin.

    This predicate is intentionally shared by the pre-generation evidence
    boundary and the final deterministic draft gate.  Keeping one rule avoids
    a phrase being withheld from validation yet still crossing the LLM
    boundary (or the reverse).
    """

    return _has_match(_BLIND_ORIGIN_PATTERNS, text)


def _posting_constraint_patterns(
    constraint: PostingConstraint,
    profile: CandidateProfile,
) -> tuple[re.Pattern[str], ...]:
    if constraint.kind not in {ConstraintKind.BLIND_FIELD, ConstraintKind.REDACTION}:
        return ()

    descriptor = unicodedata.normalize(
        "NFKC",
        " ".join(
            [*constraint.fields, constraint.description, constraint.source_quote]
        ),
    ).casefold()
    compact_descriptor = re.sub(r"\s+", "", descriptor)
    patterns: list[re.Pattern[str]] = []

    if any(keyword in compact_descriptor for keyword in ("학교", "출신대", "학력")):
        patterns.extend(_BLIND_SCHOOL_PATTERNS)
    if any(keyword in compact_descriptor for keyword in ("출신지", "출신지역", "고향")):
        patterns.extend(_BLIND_ORIGIN_PATTERNS)
    if any(keyword in compact_descriptor for keyword in ("성명", "지원자이름", "본인이름")):
        patterns.append(_BLIND_IDENTITY_PATTERN)
        if profile.name:
            escaped_name = re.escape(profile.name)
            patterns.append(
                re.compile(
                    rf"(?:이름|성명)\s*[:\uff1a]\s*{escaped_name}|"
                    rf"저는\s*{escaped_name}(?:입니다|이라고)"
                )
            )
    if any(keyword in compact_descriptor for keyword in ("나이", "연령")):
        patterns.extend(_BLIND_AGE_PATTERNS)
    if any(keyword in compact_descriptor for keyword in _EMPLOYER_FIELD_KEYWORDS):
        patterns.extend(_EMPLOYER_NAME_PATTERNS)
        organisations = {
            record.organization
            for record in (
                *profile.records.careers,
                *profile.records.experiences,
            )
            if record.organization
        }
        for organisation in sorted(organisations):
            patterns.append(
                re.compile(
                    rf"(?<![가-힣A-Za-z0-9]){re.escape(organisation)}"
                    rf"(?=에서|의|를|은|는|이|가|[\s,.)]|$)"
                )
            )
        # Structured career records enumerate known employers, but free-form
        # project evidence can mention a different client or company.  Always
        # retain the conservative proper-name heuristic; limiting it to
        # profiles without records lets such unknown names bypass both the
        # pre-LLM boundary and the final gate.
        generic = "|".join(
            re.escape(value) for value in _GENERIC_LOCATION_CONTEXT
        )
        patterns.append(
            re.compile(
                rf"(?<![가-힣A-Za-z0-9])(?!(?:{generic})에서)"
                rf"[가-힣A-Za-z][가-힣A-Za-z0-9·]{{1,30}}(?=에서)",
                re.IGNORECASE,
            )
        )
    if any(keyword in compact_descriptor for keyword in ("이메일", "전자우편", "메일주소")):
        patterns.append(_EMAIL_PATTERN)
    if any(keyword in compact_descriptor for keyword in ("전화번호", "휴대폰", "연락처")):
        patterns.append(_PHONE_PATTERN)

    for category, keywords in _CONSTRAINT_CATEGORY_KEYWORDS:
        if not any(keyword in compact_descriptor for keyword in keywords):
            continue
        for mapped_category, category_patterns in _SENSITIVE_PATTERNS:
            if mapped_category is category:
                patterns.extend(category_patterns)
                break

    # An institution may use a field name that is not in our semantic map.  We
    # only search for an explicit ``field: value`` label in that case, rather
    # than treating arbitrary words from the posting as forbidden prose.
    for field in constraint.fields:
        stripped = field.strip()
        if len(stripped) < 2:
            continue
        patterns.append(
            re.compile(rf"{re.escape(stripped)}\s*[:\uff1a]\s*\S+")
        )

    return tuple(patterns)


def contains_blocking_posting_field(
    text: str,
    profile: CandidateProfile,
    analysis: JobAnalysis,
) -> bool:
    """Use the final-output field rules at the pre-LLM boundary as well."""

    return any(
        constraint.blocking
        and _has_match(_posting_constraint_patterns(constraint, profile), text)
        for constraint in analysis.constraints
    )


def _is_ascii_identifier_number(text: str, start: int, end: int) -> bool:
    left = start
    right = end
    while left > 0 and text[left - 1] in _IDENTIFIER_CHARS:
        left -= 1
    while right < len(text) and text[right] in _IDENTIFIER_CHARS:
        right += 1
    token = text[left:right]
    if _ASCII_NUMBER_WITH_UNIT_PATTERN.fullmatch(token):
        return False
    return any(character.isascii() and character.isalpha() for character in token)


def _normalise_unit(raw: str | None) -> str | None:
    if raw is None:
        return None
    folded = raw.strip().casefold()
    aliases = {
        "퍼센트": "%",
        "millisecond": "ms",
        "milliseconds": "ms",
        "second": "s",
        "seconds": "s",
        "sec": "s",
        "secs": "s",
        "kb": "KB",
        "mb": "MB",
        "gb": "GB",
        "tb": "TB",
    }
    return aliases.get(folded, folded)


def _metric_unit(key: str) -> str | None:
    folded = key.casefold()
    if _RATIO_METRIC_KEY_PATTERN.search(folded):
        return "%"
    if re.search(
        r"(?:team|member|headcount|people|user|customer).*count|team_size",
        folded,
    ):
        return "명"
    if re.search(r"(?:^|_)ms(?:$|_)|latency_ms|duration_ms", folded):
        return "ms"
    if re.search(r"(?:seconds?|secs?|duration_s)(?:$|_)", folded):
        return "s"
    if re.search(
        r"(?:request|error|order|case|event|issue|ticket).*count|(?:^|_)count$",
        folded,
    ):
        return "건"
    if re.search(r"months?|month_count", folded):
        return "개월"
    if re.search(r"years?|year_count", folded):
        return "년"
    return None


def _numeric_tokens(text: str) -> list[_NumericToken]:
    tokens: list[_NumericToken] = []
    for match in _NUMBER_PATTERN.finditer(text):
        if _is_ascii_identifier_number(text, match.start(), match.end()):
            continue
        raw = match.group(0)
        try:
            value = Decimal(raw.replace(",", "").lstrip("+"))
        except InvalidOperation:
            continue
        unit_match = _NUMBER_UNIT_PATTERN.match(text, match.end())
        unit = _normalise_unit(unit_match.group(1) if unit_match else None)
        tokens.append(
            _NumericToken(
                value=value,
                display=raw,
                is_percent=unit == "%",
                unit=unit,
            )
        )
    return tokens


def _without_pii(text: str) -> str:
    for pattern in (
        _RESIDENT_ID_PATTERN,
        _EMAIL_PATTERN,
        _PHONE_PATTERN,
        _BANK_ACCOUNT_PATTERN,
    ):
        text = pattern.sub(" ", text)
    return text


def _supported_numbers(
    facts: Iterable[EvidenceItem],
) -> tuple[set[tuple[Decimal, str | None]], set[Decimal]]:
    values: set[tuple[Decimal, str | None]] = set()
    derived_percentages: set[Decimal] = set()
    for fact in facts:
        values.update(
            (token.value, token.unit)
            for token in _numeric_tokens(_without_pii(fact.content))
        )
        for key, metric_value in fact.metrics.items():
            metric_tokens = _numeric_tokens(str(metric_value))
            inferred_unit = _metric_unit(str(key))
            values.update(
                (token.value, token.unit or inferred_unit)
                for token in metric_tokens
            )
            if _RATIO_METRIC_KEY_PATTERN.search(str(key)):
                for token in _numeric_tokens(str(metric_value)):
                    if not token.is_percent and abs(token.value) <= 1:
                        derived_percentages.add(token.value * 100)

        if fact.date_range is not None:
            for resume_date in (fact.date_range.start, fact.date_range.end):
                if resume_date is None:
                    continue
                values.add((Decimal(resume_date.year), None))
                values.add((Decimal(resume_date.year), "년"))
                if resume_date.month is not None:
                    values.add((Decimal(resume_date.month), "월"))
                    values.add(
                        (
                            Decimal(f"{resume_date.year}.{resume_date.month:02d}"),
                            None,
                        )
                    )
    return values, derived_percentages


def _reversed_date_ranges(text: str) -> list[str]:
    reversed_ranges: list[str] = []
    for match in _NUMERIC_DATE_RANGE_PATTERN.finditer(text):
        start = (
            int(match.group("sy")),
            int(match.group("sm")),
            int(match.group("sd") or 1),
        )
        end = (
            int(match.group("ey")),
            int(match.group("em")),
            int(match.group("ed") or 1),
        )
        if start > end:
            reversed_ranges.append(match.group(0))
    return reversed_ranges


def _text_targets(draft: ResumeDraft) -> list[_TextTarget]:
    targets = [_TextTarget(draft.title, "title")]
    for section_index, section in enumerate(draft.sections):
        section_location = f"sections[{section_index}]"
        targets.append(_TextTarget(section.heading, f"{section_location}.heading"))
        for claim_index, claim in enumerate(section.claims):
            targets.append(
                _TextTarget(
                    claim.text,
                    f"{section_location}.claims[{claim_index}].text",
                    claim,
                )
            )
    return targets


def _effective_policy_mode(draft: ResumeDraft, config: GenerationConfig) -> ResumeMode:
    # When mode declarations disagree, applying the stricter blind policy keeps a
    # configuration error from becoming a privacy bypass.
    if ResumeMode.PUBLIC_BLIND in {draft.mode, config.resume_mode}:
        return ResumeMode.PUBLIC_BLIND
    return config.resume_mode


def _validate_structured_resume_completeness(
    profile: CandidateProfile,
    draft: ResumeDraft,
    collector: _FindingCollector,
) -> None:
    """Reject skeletal drafts when structured resume records are available.

    Evidence grounding answers whether a sentence is supportable; it does not
    answer whether the resulting resume is professionally complete.  This
    gate uses only typed records and section structure, so a judge cannot hide
    a one-line career or project behind inflated subjective scores.
    """

    records = profile.records
    if not records.all_records():
        # Legacy/unstructured intake cannot be assessed by this deterministic
        # rule. Deployments seeking a release-grade result should materialise
        # career, experience, education, and certification records first.
        return

    sections_by_type: dict[SectionType, list] = {}
    for section in draft.sections:
        sections_by_type.setdefault(section.section_type, []).append(section)

    def add_missing(section_type: SectionType, label: str) -> None:
        collector.add(
            code=f"CONTENT.MISSING_{section_type.value.upper()}_SECTION",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.COMPLETENESS,
            message=f"구조화된 후보자 기록에 필요한 {label} 섹션이 없습니다.",
            location="sections",
            suggestion=f"근거가 연결된 {label} 섹션을 추가하세요.",
        )

    if (records.careers or records.experiences) and not sections_by_type.get(
        SectionType.SUMMARY
    ):
        add_missing(SectionType.SUMMARY, "핵심 요약")
    if records.careers and not sections_by_type.get(SectionType.EXPERIENCE):
        add_missing(SectionType.EXPERIENCE, "경력")
    if records.experiences and not sections_by_type.get(SectionType.PROJECTS):
        add_missing(SectionType.PROJECTS, "프로젝트/직무 경험")
    if records.educations and not sections_by_type.get(SectionType.EDUCATION):
        add_missing(SectionType.EDUCATION, "교육 및 학력")
    if records.certifications and not sections_by_type.get(
        SectionType.CERTIFICATIONS
    ):
        add_missing(SectionType.CERTIFICATIONS, "자격")

    summary_claims = [
        claim
        for section in sections_by_type.get(SectionType.SUMMARY, [])
        for claim in section.claims
    ]
    if (records.careers or records.experiences) and len(summary_claims) < 2:
        collector.add(
            code="CONTENT.THIN_SUMMARY",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.COMPLETENESS,
            message="핵심 요약이 후보자의 역할과 대표 성과를 각각 보여 주지 못합니다.",
            location="sections.summary",
            suggestion="서로 다른 근거를 사용한 역할/전문성 요약과 대표 성과 요약을 2개 이상 작성하세요.",
        )

    visible_keywords = {
        keyword.casefold()
        for fact in profile.facts
        if not fact.confidential and fact.sensitive_category is None
        for keyword in fact.keywords
        if keyword.strip()
    }
    competency_sections = [
        *sections_by_type.get(SectionType.CORE_COMPETENCIES, []),
        *sections_by_type.get(SectionType.SKILLS, []),
    ]
    if len(visible_keywords) >= 4 and not competency_sections:
        collector.add(
            code="CONTENT.MISSING_COMPETENCIES_SECTION",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.COMPLETENESS,
            message="근거로 확인된 기술이 충분하지만 핵심 역량/기술 섹션이 없습니다.",
            location="sections",
            suggestion="검증된 기술을 직무 기준으로 묶은 핵심 역량 섹션을 추가하세요.",
        )
    elif competency_sections:
        competency_claims = sum(
            len(section.claims) for section in competency_sections
        )
        minimum_competencies = 2 if len(visible_keywords) < 8 else 3
        if competency_claims < minimum_competencies:
            collector.add(
                code="CONTENT.THIN_COMPETENCIES",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.COMPLETENESS,
                message="핵심 역량/기술 섹션이 확인된 기술 범위를 충분히 구조화하지 못했습니다.",
                location="sections.core_competencies",
                suggestion=f"서로 다른 역량 묶음을 최소 {minimum_competencies}개 제시하세요.",
            )

    def claims_for_record(record: object, section_type: SectionType) -> list[DraftClaim]:
        evidence_ids = set(getattr(record, "evidence_ids", []))
        return [
            claim
            for section in sections_by_type.get(section_type, [])
            for claim in section.claims
            if evidence_ids & set(claim.evidence_ids)
        ]

    for record in records.careers:
        actual = len(claims_for_record(record, SectionType.EXPERIENCE))
        minimum = min(5, max(3, len(record.evidence_ids) + 1))
        if actual < minimum:
            collector.add(
                code="CONTENT.THIN_CAREER_RECORD",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.COMPLETENESS,
                message="경력 기록이 역할과 복수의 행동·성과를 판단할 만큼 상세하지 않습니다.",
                location=f"records.careers.{record.record_id}",
                evidence_ids=record.evidence_ids,
                suggestion=f"해당 경력에 근거가 연결된 역할/성과 문장을 최소 {minimum}개 구성하세요.",
            )

    for record in records.experiences:
        actual = len(claims_for_record(record, SectionType.PROJECTS))
        minimum = min(4, max(2, len(record.evidence_ids) + 1))
        if actual < minimum:
            collector.add(
                code="CONTENT.THIN_EXPERIENCE_RECORD",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.COMPLETENESS,
                message="프로젝트/직무 경험 기록이 역할, 구현 내용, 결과를 판단할 만큼 상세하지 않습니다.",
                location=f"records.experiences.{record.record_id}",
                evidence_ids=record.evidence_ids,
                suggestion=f"해당 경험에 근거가 연결된 문장을 최소 {minimum}개 구성하세요.",
            )

    for record in records.educations:
        if not claims_for_record(record, SectionType.EDUCATION):
            collector.add(
                code="CONTENT.UNMATERIALIZED_EDUCATION_RECORD",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.COMPLETENESS,
                message="구조화된 교육/학력 기록이 초안에 반영되지 않았습니다.",
                location=f"records.educations.{record.record_id}",
                evidence_ids=record.evidence_ids,
                suggestion="학교 정책을 적용한 뒤 전공·학위·직무 관련 교육을 근거와 함께 반영하세요.",
            )

    for record in records.certifications:
        if not claims_for_record(record, SectionType.CERTIFICATIONS):
            collector.add(
                code="CONTENT.UNMATERIALIZED_CERTIFICATION_RECORD",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.COMPLETENESS,
                message="구조화된 자격 기록이 초안에 반영되지 않았습니다.",
                location=f"records.certifications.{record.record_id}",
                evidence_ids=record.evidence_ids,
                suggestion="직무 관련 자격명·발급기관·취득일을 근거와 함께 반영하세요.",
            )


def validate_resume_draft(
    profile: CandidateProfile,
    draft: ResumeDraft,
    config: GenerationConfig,
    *,
    analysis: JobAnalysis | None = None,
) -> list[QualityFinding]:
    """Return stable, deterministic findings for a typed resume draft.

    The function does not raise for cross-model inconsistencies.  This is
    intentional: findings are repair-loop input, whereas Pydantic validation is
    responsible for rejecting malformed individual objects at the intake edge.
    """

    collector = _FindingCollector()
    policy_mode = _effective_policy_mode(draft, config)
    _validate_structured_resume_completeness(profile, draft, collector)

    evidence_by_id: dict[str, EvidenceItem] = {}
    duplicate_evidence_ids: list[str] = []
    for fact in profile.facts:
        if fact.evidence_id in evidence_by_id:
            if fact.evidence_id not in duplicate_evidence_ids:
                duplicate_evidence_ids.append(fact.evidence_id)
        else:
            evidence_by_id[fact.evidence_id] = fact
    if duplicate_evidence_ids:
        collector.add(
            code="REFERENCE.DUPLICATE_EVIDENCE_ID",
            severity=QualitySeverity.CRITICAL,
            category=QualityCategory.EVIDENCE,
            message="후보자 사실 원장에 중복 evidence_id가 있습니다.",
            location="profile.facts",
            evidence_ids=duplicate_evidence_ids,
            suggestion="각 근거에 전역적으로 고유한 evidence_id를 부여하세요.",
        )
    hidden_facts = [
        fact
        for fact in profile.facts
        if fact.confidential or fact.sensitive_category is not None
    ]

    if draft.candidate_id != profile.candidate_id:
        collector.add(
            code="REFERENCE.CANDIDATE_MISMATCH",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.EVIDENCE,
            message="초안의 candidate_id가 후보자 프로필과 일치하지 않습니다.",
            location="candidate_id",
            suggestion="동일 후보자의 프로필로 초안을 다시 생성하세요.",
        )

    if analysis is not None and draft.posting_id != analysis.posting_id:
        collector.add(
            code="REFERENCE.POSTING_MISMATCH",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.JOB_ALIGNMENT,
            message="초안의 posting_id가 공고 분석과 일치하지 않습니다.",
            location="posting_id",
            suggestion="해당 공고에서 생성한 초안과 분석을 함께 사용하세요.",
        )

    if draft.mode != config.resume_mode:
        collector.add(
            code="CONFIG.MODE_MISMATCH",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.CONSISTENCY,
            message="초안 모드와 생성 설정의 이력서 모드가 일치하지 않습니다.",
            location="mode",
            suggestion="한 정책 모드로 다시 생성하거나 설정을 일치시키세요.",
        )

    if config.include_photo and SensitiveDataCategory.PHOTO not in (
        config.allowed_sensitive_categories
    ):
        collector.add(
            code="CONFIG.PHOTO_PERMISSION",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.PRIVACY,
            message="사진 포함 설정에 필요한 민감정보 허용 범주가 없습니다.",
            location="config.include_photo",
            suggestion="사진을 제외하거나 명시적 동의가 연결된 사진 범주를 허용하세요.",
        )

    prohibited_config_categories = config.allowed_sensitive_categories & {
        SensitiveDataCategory.NATIONAL_ID,
        SensitiveDataCategory.BANK_ACCOUNT,
        SensitiveDataCategory.HEALTH,
    }
    if prohibited_config_categories:
        collector.add(
            code="CONFIG.PROHIBITED_SENSITIVE_CATEGORY",
            severity=QualitySeverity.CRITICAL,
            category=QualityCategory.PRIVACY,
            message="절대 금지된 민감정보 범주가 생성 설정에 포함되어 있습니다.",
            location="config.allowed_sensitive_categories",
            suggestion="건강정보, 주민등록번호, 계좌정보 허용을 제거하세요.",
        )

    unrequested_sensitive = config.allowed_sensitive_categories - getattr(
        config, "employer_required_sensitive_categories", set()
    )
    if unrequested_sensitive:
        collector.add(
            code="CONFIG.SENSITIVE_NOT_EMPLOYER_REQUIRED",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.PRIVACY,
            message="채용사 요구 근거가 없는 민감정보 범주가 활성화되어 있습니다.",
            location="config.allowed_sensitive_categories",
            suggestion="채용사 지정 요구를 기록하거나 해당 민감정보를 제외하세요.",
        )

    if policy_mode is ResumeMode.PUBLIC_BLIND and (
        config.include_photo
        or config.allowed_sensitive_categories
        or getattr(config, "employer_required_sensitive_categories", set())
    ):
        collector.add(
            code="CONFIG.BLIND_SENSITIVE_ENABLED",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.PRIVACY,
            message="공공 블라인드 모드에서 민감정보가 활성화되어 있습니다.",
            location="config.allowed_sensitive_categories",
            suggestion="사진과 모든 민감정보 허용 범주를 비활성화하세요.",
        )

    consent_instant = datetime.combine(
        config.as_of_date, datetime.min.time(), tzinfo=timezone.utc
    )
    active_categories = {
        consent.category
        for consent in profile.consents
        if consent.is_active_at(consent_instant)
    }
    missing_consent = config.allowed_sensitive_categories - active_categories
    if missing_consent:
        missing_labels = ", ".join(
            sorted(category.value for category in missing_consent)
        )
        collector.add(
            code="CONFIG.SENSITIVE_CONSENT",
            severity=QualitySeverity.ERROR,
            category=QualityCategory.PRIVACY,
            message=f"활성 동의가 없는 민감정보 범주가 있습니다: {missing_labels}.",
            location="config.allowed_sensitive_categories",
            suggestion="유효한 목적별 동의를 연결하거나 해당 범주를 제외하세요.",
        )

    claim_locations: dict[str, str] = {}
    claims: list[DraftClaim] = []
    known_requirement_ids = (
        {requirement.requirement_id for requirement in analysis.requirements}
        if analysis is not None
        else None
    )
    for section_index, section in enumerate(draft.sections):
        if (
            policy_mode is ResumeMode.PUBLIC_BLIND
            and section.section_type is SectionType.MILITARY_SERVICE
        ):
            collector.add(
                code="PRIVACY.BLIND_MILITARY_SECTION",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.PRIVACY,
                message="공공 블라인드 본문에 병역 상세 섹션이 포함되어 있습니다.",
                location=f"sections[{section_index}]",
                suggestion="병역 상세 섹션을 제거하세요.",
            )

        for claim_index, claim in enumerate(section.claims):
            location = f"sections[{section_index}].claims[{claim_index}]"
            claims.append(claim)
            claim_locations.setdefault(claim.claim_id, location)

            if not claim.evidence_ids:
                collector.add(
                    code="GROUNDING.MISSING_EVIDENCE",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.EVIDENCE,
                    message="claim에 연결된 근거가 없습니다.",
                    location=location,
                    claim_id=claim.claim_id,
                    suggestion="실제 후보자 근거를 연결하거나 claim을 제거하세요.",
                )

            unknown_ids = [
                evidence_id
                for evidence_id in claim.evidence_ids
                if evidence_id not in evidence_by_id
            ]
            if unknown_ids:
                collector.add(
                    code="REFERENCE.UNKNOWN_EVIDENCE",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.EVIDENCE,
                    message="claim이 사실 원장에 없는 evidence_id를 참조합니다.",
                    location=f"{location}.evidence_ids",
                    claim_id=claim.claim_id,
                    evidence_ids=unknown_ids,
                    suggestion="존재하는 근거 ID로 교체하거나 claim을 제거하세요.",
                )

            if known_requirement_ids is not None:
                unknown_requirement_ids = [
                    requirement_id
                    for requirement_id in claim.requirement_ids
                    if requirement_id not in known_requirement_ids
                ]
                if unknown_requirement_ids:
                    collector.add(
                        code="REFERENCE.UNKNOWN_REQUIREMENT",
                        severity=QualitySeverity.ERROR,
                        category=QualityCategory.JOB_ALIGNMENT,
                        message="claim이 공고 분석에 없는 requirement_id를 참조합니다.",
                        location=f"{location}.requirement_ids",
                        claim_id=claim.claim_id,
                        suggestion="공고 분석에 존재하는 요구사항 ID만 연결하세요.",
                    )

            supporting_facts = [
                evidence_by_id[evidence_id]
                for evidence_id in claim.evidence_ids
                if evidence_id in evidence_by_id
            ]
            if any(
                hidden.evidence_id not in claim.evidence_ids
                and _looks_like_hidden_fact_echo(claim.text, hidden.content)
                for hidden in hidden_facts
            ):
                collector.add(
                    code="PRIVACY.HIDDEN_EVIDENCE_ECHO",
                    severity=QualitySeverity.CRITICAL,
                    category=QualityCategory.PRIVACY,
                    message=(
                        "claim이 공개 허용 근거를 참조하면서 비공개 또는 민감 "
                        "원장의 문구를 재현합니다."
                    ),
                    location=f"{location}.text",
                    claim_id=claim.claim_id,
                    evidence_ids=claim.evidence_ids,
                    suggestion="해당 문구를 제거하고 공개 허용 근거만으로 다시 작성하세요.",
                )
            confidential_ids = [
                fact.evidence_id for fact in supporting_facts if fact.confidential
            ]
            if confidential_ids:
                collector.add(
                    code="GROUNDING.CONFIDENTIAL_EVIDENCE",
                    severity=QualitySeverity.CRITICAL,
                    category=QualityCategory.PRIVACY,
                    message="claim이 외부 공개가 금지된 기밀 근거를 참조합니다.",
                    location=f"{location}.evidence_ids",
                    claim_id=claim.claim_id,
                    evidence_ids=confidential_ids,
                    suggestion="기밀 근거의 참조와 그로부터 파생된 문구를 모두 제거하세요.",
                )

            referenced_sensitive = {
                fact.sensitive_category
                for fact in supporting_facts
                if fact.sensitive_category is not None
            }
            undeclared_sensitive = referenced_sensitive - claim.sensitive_categories
            if undeclared_sensitive:
                labels = ", ".join(
                    sorted(category.value for category in undeclared_sensitive)
                )
                collector.add(
                    code="REFERENCE.UNDECLARED_SENSITIVE_EVIDENCE",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.PRIVACY,
                    message=f"claim이 표시하지 않은 민감 근거 범주를 참조합니다: {labels}.",
                    location=f"{location}.evidence_ids",
                    claim_id=claim.claim_id,
                    evidence_ids=claim.evidence_ids,
                    suggestion="민감 근거를 제거하거나 허용·동의된 범주를 명시하세요.",
                )

            disallowed_referenced = (
                referenced_sensitive
                if policy_mode is ResumeMode.PUBLIC_BLIND
                else referenced_sensitive - config.allowed_sensitive_categories
            )
            if disallowed_referenced:
                labels = ", ".join(
                    sorted(category.value for category in disallowed_referenced)
                )
                collector.add(
                    code="PRIVACY.DISALLOWED_SENSITIVE_EVIDENCE",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.PRIVACY,
                    message=f"현재 모드에서 허용되지 않은 민감 근거를 참조합니다: {labels}.",
                    location=f"{location}.evidence_ids",
                    claim_id=claim.claim_id,
                    evidence_ids=claim.evidence_ids,
                    suggestion="해당 민감 근거와 그로부터 파생된 문구를 제거하세요.",
                )
            unsupported_sensitive = {
                category
                for category in claim.sensitive_categories
                if not any(
                    fact.sensitive_category == category for fact in supporting_facts
                )
            }
            if unsupported_sensitive:
                labels = ", ".join(
                    sorted(category.value for category in unsupported_sensitive)
                )
                collector.add(
                    code="REFERENCE.UNSUPPORTED_SENSITIVE_CATEGORY",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.EVIDENCE,
                    message=f"근거가 뒷받침하지 않는 민감정보 범주가 표시되었습니다: {labels}.",
                    location=f"{location}.sensitive_categories",
                    claim_id=claim.claim_id,
                    evidence_ids=claim.evidence_ids,
                    suggestion="근거와 동의가 모두 있는 범주만 표시하세요.",
                )

            disallowed_declared = (
                set(claim.sensitive_categories)
                if policy_mode is ResumeMode.PUBLIC_BLIND
                else claim.sensitive_categories - config.allowed_sensitive_categories
            )
            if disallowed_declared:
                labels = ", ".join(
                    sorted(category.value for category in disallowed_declared)
                )
                code = (
                    "PRIVACY.BLIND_SENSITIVE_CATEGORY"
                    if policy_mode is ResumeMode.PUBLIC_BLIND
                    else "PRIVACY.DISALLOWED_SENSITIVE_CATEGORY"
                )
                collector.add(
                    code=code,
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.PRIVACY,
                    message=f"현재 모드에서 허용되지 않는 민감정보 범주입니다: {labels}.",
                    location=f"{location}.sensitive_categories",
                    claim_id=claim.claim_id,
                    evidence_ids=claim.evidence_ids,
                    suggestion="민감정보를 제거하거나 적법한 동의와 모드 정책을 확인하세요.",
                )

    targets = _text_targets(draft)
    for target in targets:
        if _has_match(_PLACEHOLDER_PATTERNS, target.text):
            collector.add(
                code="CONTENT.PLACEHOLDER",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.COMPLETENESS,
                message="최종 문서에 편집용 placeholder가 남아 있습니다.",
                location=target.location,
                claim_id=target.claim_id,
                evidence_ids=target.evidence_ids,
                suggestion="확인된 내용으로 교체하거나 해당 문구를 제거하세요.",
            )

        if _RESIDENT_ID_PATTERN.search(target.text):
            collector.add(
                code="PRIVACY.RESIDENT_ID",
                severity=QualitySeverity.CRITICAL,
                category=QualityCategory.PRIVACY,
                message="본문에 주민등록번호 형식의 값이 포함되어 있습니다.",
                location=target.location,
                claim_id=target.claim_id,
                evidence_ids=target.evidence_ids,
                suggestion="해당 값을 즉시 삭제하고 원본 및 로그의 잔존 여부도 확인하세요.",
            )
        if _EMAIL_PATTERN.search(target.text):
            collector.add(
                code="PRIVACY.EMAIL_IN_BODY",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.PRIVACY,
                message="본문에 이메일 주소가 포함되어 있습니다.",
                location=target.location,
                claim_id=target.claim_id,
                evidence_ids=target.evidence_ids,
                suggestion="이메일은 본문에서 제거하고 렌더러의 신원 블록에만 삽입하세요.",
            )
        if _PHONE_PATTERN.search(target.text):
            collector.add(
                code="PRIVACY.PHONE_IN_BODY",
                severity=QualitySeverity.ERROR,
                category=QualityCategory.PRIVACY,
                message="본문에 전화번호 형식의 값이 포함되어 있습니다.",
                location=target.location,
                claim_id=target.claim_id,
                evidence_ids=target.evidence_ids,
                suggestion="전화번호는 본문에서 제거하고 렌더러의 신원 블록에만 삽입하세요.",
            )

        detected_categories = {
            category
            for category, patterns in _SENSITIVE_PATTERNS
            if _has_match(patterns, target.text)
        }
        for category in sorted(detected_categories, key=lambda item: item.value):
            declared = (
                target.claim is not None
                and category in target.claim.sensitive_categories
            )
            if category is SensitiveDataCategory.BANK_ACCOUNT:
                # Account information is prohibited in every mode, even with consent.
                collector.add(
                    code="PRIVACY.BANK_ACCOUNT",
                    severity=QualitySeverity.CRITICAL,
                    category=QualityCategory.PRIVACY,
                    message="본문에 계좌정보로 보이는 값이 포함되어 있습니다.",
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="계좌정보를 즉시 삭제하고 원본 및 로그의 잔존 여부도 확인하세요.",
                )
            elif policy_mode is ResumeMode.PUBLIC_BLIND:
                if declared:
                    # The declared-category finding above already explains the same
                    # policy breach and is a better repair target.
                    continue
                collector.add(
                    code="PRIVACY.BLIND_SENSITIVE_CONTENT",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.PRIVACY,
                    message=(
                        "공공 블라인드 본문에서 편견을 유발할 수 있는 "
                        f"민감정보 표현이 탐지되었습니다: {category.value}."
                    ),
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="직무 수행 근거만 남기고 해당 개인정보 표현을 제거하세요.",
                )
            elif category not in config.allowed_sensitive_categories:
                if declared:
                    continue
                collector.add(
                    code="PRIVACY.DISALLOWED_SENSITIVE_CONTENT",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.PRIVACY,
                    message=(
                        "현재 모드에서 허용되지 않은 민감정보 표현이 "
                        f"탐지되었습니다: {category.value}."
                    ),
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="해당 개인정보 표현을 제거하세요.",
                )
            elif target.claim is not None and not declared:
                collector.add(
                    code="PRIVACY.UNDECLARED_SENSITIVE_CONTENT",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.PRIVACY,
                    message=(
                        "허용된 민감정보가 claim 메타데이터에 표시되지 "
                        f"않았습니다: {category.value}."
                    ),
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="민감정보 범주와 이를 뒷받침하는 동의 근거를 명시하세요.",
                )

        if policy_mode is ResumeMode.PUBLIC_BLIND:
            if _has_match(_BLIND_SCHOOL_PATTERNS, target.text):
                collector.add(
                    code="PRIVACY.BLIND_SCHOOL",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.BIAS,
                    message="공공 블라인드 본문에 학교를 식별할 수 있는 표현이 있습니다.",
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="학교명은 제거하고 직무 관련 교육 내용만 남기세요.",
                )
            if contains_public_blind_origin(target.text):
                collector.add(
                    code="PRIVACY.BLIND_ORIGIN",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.BIAS,
                    message="공공 블라인드 본문에 출신지를 드러내는 표현이 있습니다.",
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="출신지 표현을 제거하세요.",
                )
            if _has_match(_BLIND_AGE_PATTERNS, target.text):
                collector.add(
                    code="PRIVACY.BLIND_AGE",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.BIAS,
                    message="공공 블라인드 본문에 연령을 드러내는 표현이 있습니다.",
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="연령 표현을 제거하세요.",
                )

            identity_found = _has_match(
                _candidate_identity_patterns(profile), target.text
            )
            if identity_found:
                collector.add(
                    code="PRIVACY.BLIND_IDENTITY",
                    severity=QualitySeverity.ERROR,
                    category=QualityCategory.BIAS,
                    message="공공 블라인드 본문에 지원자 이름을 드러내는 표현이 있습니다.",
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="이름은 심사용 본문에서 제거하고 본인확인 영역과 분리하세요.",
                )

    if analysis is not None:
        for constraint in analysis.constraints:
            patterns = _posting_constraint_patterns(constraint, profile)
            if not patterns:
                continue
            for target in targets:
                if not _has_match(patterns, target.text):
                    continue
                field_labels = ", ".join(constraint.fields)
                collector.add(
                    code="PRIVACY.POSTING_FIELD_LEAK",
                    severity=(
                        QualitySeverity.ERROR
                        if constraint.blocking
                        else QualitySeverity.WARNING
                    ),
                    category=QualityCategory.BIAS,
                    message=(
                        "공고별 블라인드/삭제 제약에 지정된 필드가 본문에 "
                        f"노출되었습니다 ({constraint.constraint_id}: {field_labels})."
                    ),
                    location=target.location,
                    claim_id=target.claim_id,
                    evidence_ids=target.evidence_ids,
                    suggestion="공고 원문의 해당 필드 규칙에 맞게 표현을 삭제하거나 비식별화하세요.",
                )

    first_claim_by_text: dict[str, DraftClaim] = {}
    for claim in claims:
        normalised = _normalise_claim_text(claim.text)
        previous = first_claim_by_text.get(normalised)
        if previous is None:
            first_claim_by_text[normalised] = claim
            continue
        collector.add(
            code="CONTENT.DUPLICATE_CLAIM",
            severity=QualitySeverity.WARNING,
            category=QualityCategory.CONSISTENCY,
            message=f"동일한 claim 문구가 앞선 claim {previous.claim_id!r}과 중복됩니다.",
            location=claim_locations.get(claim.claim_id),
            claim_id=claim.claim_id,
            evidence_ids=claim.evidence_ids,
            suggestion="중복 문구를 제거하거나 서로 다른 근거와 기여를 명확히 구분하세요.",
        )

    number_severity = (
        QualitySeverity.ERROR if config.strict_evidence else QualitySeverity.WARNING
    )
    requirement_by_id = (
        {item.requirement_id: item for item in analysis.requirements}
        if analysis is not None
        else {}
    )
    for claim in claims:
        for requirement_id in claim.requirement_ids:
            requirement = requirement_by_id.get(requirement_id)
            if requirement is not None and not _claim_mentions_requirement(
                claim.text, requirement
            ):
                collector.add(
                    code="ALIGNMENT.REQUIREMENT_MISMATCH",
                    severity=number_severity,
                    category=QualityCategory.JOB_ALIGNMENT,
                    message=(
                        "claim 문구에 연결된 직무 요건의 핵심 표현이 "
                        "확인되지 않습니다."
                    ),
                    location=f"{claim_locations.get(claim.claim_id, 'claims')}.text",
                    claim_id=claim.claim_id,
                    evidence_ids=claim.evidence_ids,
                    suggestion=(
                        "요건과 직접 맞닿는 표현을 근거 범위 안에서 명시하거나 "
                        "잘못된 requirement ID 연결을 제거하세요."
                    ),
                )
        supporting_facts = [
            evidence_by_id[evidence_id]
            for evidence_id in claim.evidence_ids
            if evidence_id in evidence_by_id
        ]
        if not supporting_facts:
            # Missing/unknown evidence has already produced the primary repair
            # finding; reporting every number as well would be redundant noise.
            continue
        reversed_ranges = _reversed_date_ranges(claim.text)
        if reversed_ranges:
            collector.add(
                code="CHRONOLOGY.REVERSED_RANGE",
                severity=number_severity,
                category=QualityCategory.CHRONOLOGY,
                message="claim의 시작일이 종료일보다 늦습니다.",
                location=f"{claim_locations.get(claim.claim_id, 'claims')}.text",
                claim_id=claim.claim_id,
                evidence_ids=claim.evidence_ids,
                suggestion="근거의 날짜 범위와 대조해 시작·종료 순서를 바로잡으세요.",
            )
        supported, derived_percentages = _supported_numbers(supporting_facts)
        unsupported_displays: list[str] = []
        seen_values: set[tuple[Decimal, str | None]] = set()
        for token in _numeric_tokens(_without_pii(claim.text)):
            key = (token.value, token.unit)
            if key in seen_values:
                continue
            seen_values.add(key)
            if (token.value, token.unit) in supported:
                continue
            if token.is_percent and token.value in derived_percentages:
                continue
            unsupported_displays.append(token.display)
        if unsupported_displays:
            values = ", ".join(unsupported_displays)
            collector.add(
                code="GROUNDING.UNSUPPORTED_NUMBER",
                severity=number_severity,
                category=QualityCategory.EVIDENCE,
                message=f"claim의 숫자가 연결 근거의 content 또는 metrics에 없습니다: {values}.",
                location=f"{claim_locations.get(claim.claim_id, 'claims')}.text",
                claim_id=claim.claim_id,
                evidence_ids=claim.evidence_ids,
                suggestion="근거에 있는 정확한 숫자로 교체하거나 숫자 표현을 제거하세요.",
            )

        unsupported_terms = _unsupported_technical_terms(claim, supporting_facts)
        if unsupported_terms:
            collector.add(
                code="GROUNDING.UNSUPPORTED_TECH_TERM",
                severity=number_severity,
                category=QualityCategory.EVIDENCE,
                message=(
                    "claim의 기술 용어가 연결 근거의 content, keywords 또는 "
                    "metrics에 없습니다: " + ", ".join(unsupported_terms) + "."
                ),
                location=f"{claim_locations.get(claim.claim_id, 'claims')}.text",
                claim_id=claim.claim_id,
                evidence_ids=claim.evidence_ids,
                suggestion="근거에 있는 기술 용어로 교체하거나 해당 표현을 제거하세요.",
            )

        low_support, unsupported_words = _low_lexical_support(
            claim, supporting_facts
        )
        if low_support:
            preview = ", ".join(unsupported_words[:8])
            collector.add(
                code="GROUNDING.LOW_LEXICAL_SUPPORT",
                severity=number_severity,
                category=QualityCategory.EVIDENCE,
                message=(
                    "claim의 핵심 표현 다수가 연결 근거에서 확인되지 않습니다: "
                    f"{preview}."
                ),
                location=f"{claim_locations.get(claim.claim_id, 'claims')}.text",
                claim_id=claim.claim_id,
                evidence_ids=claim.evidence_ids,
                suggestion=(
                    "연결 근거에 명시된 맥락·행동·결과만 사용하거나 추가 "
                    "근거를 제공하세요."
                ),
            )

    return collector.findings


# Short compatibility name for callers that already operate on ResumeDraft.
validate_draft = validate_resume_draft


__all__ = [
    "contains_blocking_posting_field",
    "contains_public_blind_origin",
    "validate_draft",
    "validate_resume_draft",
]