import numpy as np

# 1. DB 에서 벡터를 읽는다 (문자 -> 숫자)
ids, matrix = load_vectors("chunk_vectors", "chunk_id")   # (1560, 384) 행렬

# 2. 질문도 벡터로
q = embeddings.embed_query("민감성인데 써도 되나요")        # 384개

# 3. 전부와 비교한다. 길이가 1 이라 행렬 곱 한 번이면 끝난다
scores = matrix @ np.array(q)                            # 1,560개 점수

# 4. 큰 것부터 k 개
top = np.argsort(-scores)[:4]

def load_documents(sql, params=()):
    """SQL 결과를 LangChain `Document` 목록으로 바꾼다.

    약속: 첫 컬럼이 id, 둘째가 본문, 셋째가 벡터 문자, 나머지는 metadata 로 들어간다.
    """
    from langchain_core.documents import Document

    cur = con.execute(sql, params)
    columns = [c[0] for c in cur.description]
    docs, vectors = [], []
    for row in cur.fetchall():
        record = dict(zip(columns, row))
        doc_id = str(record.pop(columns[0]))
        content = record.pop(columns[1])
        vectors.append(json.loads(record.pop(columns[2])))
        docs.append(Document(id=doc_id, page_content=content, metadata=record))
    return docs, vectors

"""꺼내오는 자리 ― SQL 로 집계하고, 벡터로 찾는다.

오늘 오후에 세 가지가 늘었다.
    get_embeddings()   질문을 숫자로 바꾸는 모델 (처음 부를 때 올린다)
    search_chunks()    질문 -> 조각 검색 -> 원문 섹션 (small-to-big)
    rank_products()    고객 벡터와 가까운 상품

🔴 벡터를 **여기서 직접 읽는다.** 파일 맨 위에서 표를 통째로 메모리에 올린다.
   지금은 이게 제일 단순하다. 5일차 5교시에 저장소 뒤로 숨기면서 고친다.
"""

import numpy as np
from langchain_core.vectorstores import InMemoryVectorStore

from app.core.config import EMBED_MODEL
from app.core.db import dicts, load_documents, load_vectors, one

# 🔴 import 하는 순간 벡터 표가 있어야 한다 ― 03_embed.py 를 돌리기 전에는 여기서 터진다
PRODUCT_IDS, PRODUCT_MATRIX = load_vectors("product_vectors", "product_id")
CUSTOMER_IDS, CUSTOMER_MATRIX = load_vectors("customer_vectors", "customer_id")

_embeddings = None       # 임베딩기는 무겁다. 첫 질문이 들어올 때 올린다
_chunk_store = None      # 조각 벡터스토어도 그때 같이 만든다


def customer_list(limit=None):
    """고객 목록 + 각자 구매 건수."""
    rows = dicts("""
        SELECT customers.customer_id, customers.name, customers.age, customers.gender,
               customers.skin_type, customers.city,
               COUNT(purchases.purchase_id) AS n_purchases
        FROM customers
        LEFT JOIN purchases ON purchases.customer_id = customers.customer_id
                           AND purchases.is_holdout = 0
        GROUP BY customers.customer_id
        ORDER BY customers.customer_id
    """)
    return rows[:limit] if limit else rows


def dashboard(customer_id):
    """한 고객에 대해 아는 것을 전부 모아서 돌려준다. 없는 고객이면 None."""
    profile = dicts("""
        SELECT customer_id, name, age, gender, skin_type, city
        FROM customers WHERE customer_id = ?
    """, (customer_id,))

    if not profile:
        return None

    purchases = dicts("""
        SELECT products.product_id, products.name, products.category, products.price,
               purchases.purchased_at, purchases.rating, purchases.review
        FROM purchases
        JOIN products ON purchases.product_id = products.product_id
        WHERE purchases.customer_id = ? AND purchases.is_holdout = 0
        ORDER BY purchases.purchased_at DESC
    """, (customer_id,))

    by_category = {}
    for row in purchases:
        by_category[row["category"]] = by_category.get(row["category"], 0) + 1

    ratings = [row["rating"] for row in purchases if row["rating"] is not None]

    return {
        "customer": {**profile[0], "n_purchases": len(purchases)},
        "avg_rating": round(sum(ratings) / len(ratings), 2) if ratings else None,
        "total_spent": sum(row["price"] for row in purchases),
        "by_category": by_category,
        "purchases": purchases,
    }


def get_embeddings():
    """질문을 숫자로 바꾸는 모델. 처음 부를 때 한 번만 올린다."""
    global _embeddings
    if _embeddings is not None:
        return _embeddings

    from huggingface_hub.utils import disable_progress_bars
    from huggingface_hub.utils import logging as hub_logging
    from transformers import logging as hf_logging

    hf_logging.set_verbosity_error()
    hf_logging.disable_progress_bar()
    hub_logging.set_verbosity_error()
    disable_progress_bars()

    from langchain_huggingface import HuggingFaceEmbeddings

    _embeddings = HuggingFaceEmbeddings(
        model_name=EMBED_MODEL,
        # 🔴 파이프라인과 **같은 조건**으로 올린다. 다른 자로 재면 검색이 어긋난다
        model_kwargs={"device": "cpu"},
        encode_kwargs={"normalize_embeddings": True},
    )
    return _embeddings


def get_chunk_store():
    """조각 벡터스토어. DB 의 벡터를 그대로 넣는다 (다시 임베딩하지 않는다)."""
    global _chunk_store
    if _chunk_store is not None:
        return _chunk_store

    docs, vectors = load_documents("""
        SELECT chunks.chunk_id, chunks.text, chunk_vectors.vector,
               chunks.product_id, chunks.section, chunks.section_id, chunks.body
        FROM chunks
        JOIN chunk_vectors ON chunks.chunk_id = chunk_vectors.chunk_id
        ORDER BY chunks.chunk_id
    """)
    store = InMemoryVectorStore(get_embeddings())
    # 🔴 속을 직접 채운다. 벡터스토어의 속은 그냥 이렇게 생긴 딕셔너리다
    store.store = {
        doc.id: {"id": doc.id, "vector": vector,
                 "text": doc.page_content, "metadata": doc.metadata}
        for doc, vector in zip(docs, vectors)
    }
    _chunk_store = store
    return _chunk_store


def search_chunks(question, k=4, product_ids_only=None):
    """질문으로 조각을 찾고, 원문 섹션을 같이 들고 온다 (small-to-big)."""
    store = get_chunk_store()
    keep = set(product_ids_only) if product_ids_only else None
    found = store.similarity_search_with_score(
        question, k=k,
        # filter 는 조각마다 이 함수를 물어본다. metadata 만 본다 ― 본문은 안 본다
        filter=(lambda doc: doc.metadata["product_id"] in keep) if keep else None,
    )

    out = []
    for doc, score in found:
        # 🔴 찾은 건 조각인데, 넘기는 건 그 조각이 속한 원문 섹션이다
        section_text = one("SELECT text FROM sections WHERE section_id = ?",
                           (doc.metadata["section_id"],))[0]
        name = one("SELECT name FROM products WHERE product_id = ?",
                   (doc.metadata["product_id"],))[0]
        out.append({"product_id": doc.metadata["product_id"],
                    "product_name": name,
                    "section": doc.metadata["section"],
                    "score": round(float(score), 4),
                    "text": section_text})
    return out


def rank_products(customer_id, n=5):
    """고객 벡터와 가까운 상품 n 개."""
    if customer_id not in CUSTOMER_IDS:
        return []
    me = CUSTOMER_MATRIX[CUSTOMER_IDS.index(customer_id)]
    scores = PRODUCT_MATRIX @ me          # 내적 = 코사인 (길이가 1 이라서)
    order = np.argsort(-scores)[:n]
    picked = [PRODUCT_IDS[i] for i in order]

    rows = {row["product_id"]: row for row in dicts(
        f"SELECT product_id, name, category, price FROM products "
        f"WHERE product_id IN ({','.join('?' * len(picked))})", picked)}
    return [{**rows[pid], "score": round(float(scores[i]), 4)}
            for pid, i in zip(picked, order)]


if __name__ == "__main__":
    import time

    cid = "C001"
    board = dashboard(cid)
    print(f"{board['customer']['name']} · {board['customer']['skin_type']} · "
          f"구매 {board['customer']['n_purchases']}건")

    print("\n가까운 상품 3개:")
    for row in rank_products(cid, n=3):
        print(f"  {row['score']:.3f}  {row['name']:26s} {row['price']:>7,}원")

    started = time.perf_counter()
    store = get_chunk_store()
    print(f"\n벡터스토어 준비 {time.perf_counter() - started:.1f}초 "
          f"(조각 {len(store.store):,}개 · 다시 임베딩하지 않았다)")

    print("\n청크 검색 ― 민감성인데 써도 되나요")
    for source in search_chunks("민감성인데 써도 되나요"):
        print(f"  {source['score']:.3f} [{source['product_name']} > {source['section']}]")

 pipeline/
   03_embed.py            무엇을 골라 오나 (순서)
-      def product_text()       <- 여기 있던 셋이
-      def top()
-      def customer_text()
   prep/embedding.py      어떤 글로 적나 · 그 글을 숫자로
+      def product_text()       <- 여기로 간다
+      def top()
+      def customer_text()

- import time
- from collections import Counter
+ import time
- def product_text(row):
-     """상품 한 줄을 검색용 문장으로. 상세(detail)는 일부러 뺀다."""
-     name, brand, category, price, skin_type, ingredient, concern, tags, desc = row
-     return (f"{name} · {brand} · {category} · {price}원 · {skin_type} · "
-             f"{ingredient} · {concern} · {tags} · {desc}")
-
-
- def top(values, n=3):
-     """제일 자주 나온 것 n 개를 가운뎃점으로 잇는다."""
-     return " · ".join(value for value, _ in Counter(values).most_common(n))
-
-
- def customer_text(skin_type, purchases):
-     """고객 한 명을 **취향 한 줄**로 만든다.
-     후기를 안 넣는다. 상품 벡터에 있는 낱말로만 만든다 ― 3교시에 재서 정했다.
-     """
-     ratings = [rating for *_, rating in purchases]
-     return (f"{skin_type} 피부 · 선호 카테고리 {top([p[1] for p in purchases])} · "
-             f"자주 쓴 성분 {top([p[2] for p in purchases])} · "
-             f"관심 고민 {top([p[3] for p in purchases])} · "
-             f"평균 별점 {sum(ratings) / len(ratings):.1f}")
+ # 🔴 문장을 만드는 함수 셋은 prep/embedding.py 로 갔다. 「상품 한 줄을 어떤
+ #    문장으로 적나」는 순서를 정하는 일이 아니라 검색 품질을 정하는 결정이다.
+ #    그리고 04_verify.py 가 토큰을 다시 잴 때 **같은 함수**를 부른다
-                      [product_text(x[1:]) for x in r])
+                      [embedding.product_text(x[1:]) for x in r])
-                       [customer_text(skin_of[c], history[c]) for c in cids])
+                       [embedding.customer_text(skin_of[c], history[c]) for c in cids])

# ═══════════════════════════════════════════════ ① 무엇을 벡터로 만드나

def product_text(row):
    """상품 한 줄을 검색용 문장으로. 상세(detail)는 일부러 뺀다 ―
    상세는 '어떤 제품인가'가 아니라 '어떻게 쓰나'를 적은 글이라 추천 신호가 아니다."""
    name, brand, category, price, skin_type, ingredient, concern, tags, desc = row
    return (f"{name} · {brand} · {category} · {price}원 · {skin_type} · "
            f"{ingredient} · {concern} · {tags} · {desc}")


def top(values, n=3):
    """제일 자주 나온 것 n 개를 가운뎃점으로 잇는다."""
    return " · ".join(value for value, _ in Counter(values).most_common(n))


def customer_text(skin_type, purchases):
    """고객 한 명을 **취향 한 줄**로 만든다.

    🔴 후기를 안 넣는다. 상품 벡터에 있는 낱말(카테고리 · 성분 · 고민 · 피부타입)로만
       만든다. 고객 벡터는 상품 벡터와 **같은 공간에서 비교**되므로, 상품 쪽에 없는
       낱말은 신호가 아니라 잡음이 된다.

       재 본 값 (3일차 3교시 · hit@5):
           후기 이어붙이기 10.7% · 취향만 9.7% · 취향+나이지역 12.3% · 취향+후기 7.7%
       ④는 확실히 나쁘고, 앞 셋은 못 가른다 ― 차이 2.6%p 는 흔들림 안이다.
       그래서 **제일 짧고 사람이 읽을 수 있는 것**을 골랐다. 「왜 이걸 추천했나」를
       화면에 그대로 쓸 수 있다.
    """
    ratings = [rating for *_, rating in purchases]
    return (f"{skin_type} 피부 · 선호 카테고리 {top([p[1] for p in purchases])} · "
            f"자주 쓴 성분 {top([p[2] for p in purchases])} · "
            f"관심 고민 {top([p[3] for p in purchases])} · "
            f"평균 별점 {sum(ratings) / len(ratings):.1f}")

- import numpy as np
+ import time
+
+ import numpy as np
- from app.core.db import load_vectors
+ from app.core.db import load_vectors
+ from pipeline.prep import chunking, embedding

# ═════════════════════════ 3일차 6교시 ― 어느 쪽이 나은가를 잰다 (5~6번)
#
# 🔴 위쪽은 '맞나'를 묻는다 (참/거짓이라 problems 에 쌓인다).
#    여기부터는 '어느 쪽이 나은가'를 묻는다 ― 숫자를 나란히 놓고 사람이 고른다

# ─────────────────────────────────────────────── 5. 합치기 (max vs mean)

def calculate_scores(customer_matrix, product_matrix, chunk_matrix,
                     chunk_ids, product_ids, product_of):
    """고객 x 상품 점수를 세 가지 방법으로 만든다. 돌려주는 것: {방법 이름: 점수 행렬}

    점수 행렬의 모양은 전부 (고객 수, 상품 수) 다. 그래야 같은 자로 잰 셈이 된다.

        상품 요약    상품을 한 문장으로 적은 벡터와 곧바로 견준다 (기준선)
        조각 max     그 상품 조각 중 **제일 잘 맞는 하나**의 점수를 쓴다
        조각 mean    그 상품 조각 **전부의 평균**을 쓴다

    max 는 조각 하나가 우연히 튀면 같이 튄다. mean 은 중요한 조각 하나가
    상관없는 조각들에 묻힌다. 어느 쪽이 나은지는 재 봐야 안다 ― 그게 아래 hit@k 다.
    """
    product_scores = customer_matrix @ product_matrix.T      # (고객, 상품)
    chunk_scores = customer_matrix @ chunk_matrix.T          # (고객, 조각)

    # 어느 열이 어느 상품의 조각인지 미리 묶어 둔다. 안 그러면 상품마다 다시 훑는다
    columns_of = {}
    for column, chunk_id in enumerate(chunk_ids):
        columns_of.setdefault(product_of[chunk_id], []).append(column)

    max_scores = np.stack(
        [chunk_scores[:, columns_of[pid]].max(axis=1) for pid in product_ids], axis=1)
    mean_scores = np.stack(
        [chunk_scores[:, columns_of[pid]].mean(axis=1) for pid in product_ids], axis=1)

    return {"상품 요약 벡터 (기준선)": product_scores,
            "조각 벡터 · max 로 합치기": max_scores,
            "조각 벡터 · mean 으로 합치기": mean_scores}


def hit_at(scores, customer_ids, product_ids, bought, answers, ks=(1, 3, 5)):
    """숨겨 둔 정답이 상위 k 안에 오나 센다. 돌려주는 것: {k: 맞힌 비율(%)}

    이미 산 상품은 후보에서 뺀다 ― 산 것을 또 추천하는 건 맞혀도 의미가 없다.
    k 가 커지면 맞힐 기회가 느니 보통 hit@1 < hit@3 < hit@5 다.
    """
    hits = {k: 0 for k in ks}
    for row, customer_id in enumerate(customer_ids):
        ranked = [product_ids[i] for i in np.argsort(-scores[row])
                  if product_ids[i] not in bought.get(customer_id, ())]
        for k in ks:
            hits[k] += answers[customer_id] in ranked[:k]
    return {k: count / len(customer_ids) * 100 for k, count in hits.items()}


def compare_recommendations(con, vectors, token_result):
    """세 방법을 같은 자로 재서 나란히 찍는다. 돌려주는 것: {방법 이름: {k: 비율}}

    평균 토큰을 같이 보는 이유: hit 만 보면 품질만 보인다. 벡터 하나를 만드는 데
    글이 얼마나 들어갔는지를 옆에 놓아야 **값을 하는지**가 보인다.
    """
    customer_ids, customer_matrix = vectors["customer"]
    product_ids, product_matrix = vectors["product"]
    chunk_ids, chunk_matrix = vectors["chunk"]

    answers = dict(con.execute(
        "SELECT customer_id, product_id FROM purchases WHERE is_holdout = 1"))
    bought = {}
    for customer_id, product_id in con.execute(
            "SELECT customer_id, product_id FROM purchases WHERE is_holdout = 0"):
        bought.setdefault(customer_id, set()).add(product_id)

    product_of = dict(con.execute("SELECT chunk_id, product_id FROM chunks"))

    # 🔴 03_embed.py 가 쓴 **바로 그 함수**로 문장을 다시 만들어 토큰을 센다.
    #    여기서 문장을 손으로 다시 조립하면, 만들 때와 잴 때가 어긋나도 아무도 모른다
    product_rows = con.execute("""
        SELECT name, brand, category, price, skin_type,
               ingredient, concern, tags, description
        FROM products ORDER BY product_id
    """).fetchall()
    product_texts = [embedding.product_text(row) for row in product_rows]
    average_product_tokens = sum(
        chunking.count_tokens(text) for text in product_texts) / len(product_texts)

    # max 와 mean 은 같은 조각 벡터를 쓴다. 그래서 평균 토큰이 같다
    average_chunk_tokens = token_result["average_chunk_tokens"]
    average_tokens = {
        "상품 요약 벡터 (기준선)": average_product_tokens,
        "조각 벡터 · max 로 합치기": average_chunk_tokens,
        "조각 벡터 · mean 으로 합치기": average_chunk_tokens,
    }

    started = time.perf_counter()
    score_sets = calculate_scores(customer_matrix, product_matrix, chunk_matrix,
                                  chunk_ids, product_ids, product_of)
    elapsed = time.perf_counter() - started

    print(f"  고객 {len(customer_ids)}명 · 상품 {len(product_ids)}개 · "
          f"조각 {len(chunk_ids):,}개 전부 비교하는 데 {elapsed * 1000:.0f}ms\n")
    print(f"  {'무엇으로 찾나':28s} {'평균 토큰':>10s} "
          f"{'hit@1':>7s} {'hit@3':>7s} {'hit@5':>7s}")

    hit_results = {}
    for label, scores in score_sets.items():
        hits = hit_at(scores, customer_ids, product_ids, bought, answers)
        hit_results[label] = hits
        print(f"  {label:28s} {average_tokens[label]:>10.1f} "
              f"{hits[1]:>6.1f}% {hits[3]:>6.1f}% {hits[5]:>6.1f}%")

    print()
    print("  읽는 법: 6일차 2교시에 잰 '자의 흔들림'은 30명 표본에서 16.7%p 다.")
    print("  여기는 300명 전수라 그만큼은 아니지만, 1%p 남짓한 차이는 여전히 못 믿는다.")
    print("  그리고 상세 조각은 애초에 추천 신호가 아니다 ― 추천은 상품 요약 벡터로 한다.")
    print("  조각 벡터가 일하는 곳은 추천이 아니라 '상품 질문에 근거 대기'(4일차 2교시) 다")

    return hit_results


# ─────────────────────────────────────────────── 6. 눈으로

def inspect_search_results(con, chunk_ids, chunk_matrix, questions, embed_model):
    """실제 질문을 던져 상위 3개를 눈으로 본다. 돌려주는 것: {질문: [섹션 이름, ...]}

    숫자만 보면 검색이 사람 눈에 말이 되는지는 모른다. 그래서 두 개를 던진다 ―
    되는 것 하나, 안 되는 것 하나.
    """
    # 🔴 앱과 **똑같은 임베딩기**를 쓴다. 파이프라인과 앱이 다른 자를 쓰면 그 순간
    #    검색이 어긋난다. 여기서 HuggingFaceEmbeddings 를 직접 부르면 나중에
    #    상용으로 갈아끼울 때 'text-embedding-3-small' 을 HuggingFace 에서
    #    찾다가 죽는다 ― 실제로 당했다. 그래서 앱의 함수를 그대로 부른다.
    #    파일 맨 위가 아니라 여기서 부르는 이유: retrieve 는 import 되는 순간
    #    벡터 표를 읽는다. 1~5번만 보고 싶을 때까지 그걸 끌고 올 이유가 없다
    from app.features.retrieve import get_embeddings

    model = get_embeddings()
    question_matrix = np.array(model.embed_documents(questions), dtype="float32")

    meta = {chunk_id: (product_id, section, body)
            for chunk_id, product_id, section, body
            in con.execute("SELECT chunk_id, product_id, section, body FROM chunks")}

    top_sections = {}
    for question, question_vector in zip(questions, question_matrix):
        scores = chunk_matrix @ question_vector       # 길이가 1 이라 이게 코사인이다
        ranks = np.argsort(-scores)[:3]

        print(f"\n  Q. {question}")
        top_sections[question] = [meta[chunk_ids[rank]][1] for rank in ranks]
        for rank in ranks:
            product_id, section, body = meta[chunk_ids[rank]]
            print(f"     {scores[rank]:.3f}  [{product_id} > {section}] "
                  f"{body[:48].replace(chr(10), ' ')}...")

    # 두 번째 질문이 이 데이터의 급소다. 「환불」이라는 낱말이 문서에 없기 때문이다
    print()
    for word in ("환불", "반품", "교환"):
        n = con.execute("SELECT COUNT(*) FROM chunks WHERE body LIKE ?",
                        (f"%{word}%",)).fetchone()[0]
        print(f"  '{word}' 이 들어간 조각: {n:,}개")
    print("  우리 문서는 '환불' 이라는 낱말을 한 번도 안 쓴다. '교환·반품' 으로만 적혀 있다.")

    # 🔴 결과를 **보고** 말한다 ― 미리 적어 둔 결론을 찍지 않는다.
    #    로컬 e5-small 은 못 이었고, 상용 text-embedding-3-small 은 이었다 (둘 다 실측)
    refund_top = top_sections.get("환불하고 싶은데 어떻게 하나요", [])
    if refund_top and refund_top[0] == "배송 및 교환":
        print(f"  이 임베딩({embed_model})은 '환불'과 '교환·반품'을 이어 냈다 "
              "-> 1위 [배송 및 교환]")
        print("  같은 질문을 e5-small 로 던지면 엉뚱한 섹션이 1위로 온다. 모델이 하는 일이 이거다")
    elif refund_top:
        print(f"  이 임베딩({embed_model})은 그 둘을 못 이었다 -> 1위 [{refund_top[0]}]")
        print("  낱말이 다르면 못 찾는다. 접두어(query:/passage:)를 붙여도 안 이어졌다 (재 봤다)")
    print("  -> 어느 쪽이든 벡터 검색만 믿으면 안 된다. 그래서 4일차 4교시에서 SQL 필터와 섞고,")
    print("     6일차 5교시에서 출처를 화면에 띄운다. 근거가 보이면 사람이 틀린 걸 알아챈다")

    return top_sections

-     4. 토큰      조각 분포. 상한을 넘어 잘리는 것은 없는가
+     4. 토큰      조각 분포. 상한을 넘어 잘리는 것은 없는가
+     5. 합치기    한 상품의 조각 점수를 max 로 합칠까 mean 으로 합칠까 (실측)
+     6. 눈으로    실제 질문 두 개를 던져 본다
- from pathlib import Path
+ from pathlib import Path
+
+ from huggingface_hub.utils import disable_progress_bars
+ from huggingface_hub.utils import logging as hub_logging
+ from transformers import logging as hf_logging
- sys.stdout.reconfigure(errors="replace")
+ sys.stdout.reconfigure(errors="replace")
+
+ hf_logging.set_verbosity_error()
+ hf_logging.disable_progress_bar()   # 가중치 로딩 진행바
+ hub_logging.set_verbosity_error()
+ disable_progress_bars()
- verifying.print_final_result(problems)
+ # ═══════════════════════════════════════════════ 5. 합치기
+ banner("5. 한 상품의 조각 점수를 어떻게 합치나 ― max vs mean")
+ verifying.compare_recommendations(con, vectors, token_result)
+
+ # ═══════════════════════════════════════════════ 6. 눈으로
+ banner("6. 눈으로 ― 실제 질문을 던져 본다 (되는 것 하나, 안 되는 것 하나)")
+ chunk_ids, chunk_matrix = vectors["chunk"]
+ verifying.inspect_search_results(
+     con, chunk_ids, chunk_matrix,
+     ["배송은 얼마나 걸리나요", "환불하고 싶은데 어떻게 하나요"], EMBED_MODEL)
+
+ verifying.print_final_result(problems)

{
  "설명": "상품 Q&A 골든셋. 청킹 방식을 판정한다 ― 정답 섹션이 검색 상위에 오나",
  "만든 법": "전부 DB 의 실제 문장에서 뽑았다",
  "items": [
    {"id": 1, "question": "비타민C 필링 로션은 민감성 피부가 써도 되나요?",
     "product_id": "P001", "section": "주의사항",
     "keywords": ["민감성", "권하지 않습니다"]}
  ]
}

"""상품 Q&A 골든셋 채점 ― 검색이 제 일을 하는지 본다.

두 가지를 잰다.
    1) 골든셋이 정말 맞나   keywords 가 그 섹션 원문에 실제로 있는지 확인한다
    2) 검색이 찾아오나     질문을 던져 상위 k 에 정답 섹션이 오는지 센다 (hit@1/3/5)

실행:  python eval/qa_check.py
"""

import json
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
sys.stdout.reconfigure(errors="replace")

from app.core.db import one
from app.features.retrieve import search_chunks

GOLDEN = json.loads((Path(__file__).parent / "qa_golden.json").read_text(encoding="utf-8"))
ITEMS = GOLDEN["items"]

# ─────────────────────────────────────────── 1. 골든셋 자체를 검사한다
broken = []
for item in ITEMS:
    row = one("SELECT text FROM sections WHERE product_id = ? AND section = ?",
              (item["product_id"], item["section"]))
    if row is None:
        broken.append((item["id"], "그런 섹션이 없다"))
        continue
    missing = [w for w in item["keywords"] if w not in row[0]]
    if missing:
        broken.append((item["id"], f"원문에 없는 낱말: {missing}"))

print(f"  문항 {len(ITEMS)}개 · 어긋난 것 {len(broken)}개")
for item_id, why in broken:
    print(f"      {item_id}. {why}")

# ─────────────────────────────────────────── 2. 검색이 정답 섹션을 찾아오나
hits = {1: 0, 3: 0, 5: 0}
missed = []
for item in ITEMS:
    found = search_chunks(item["question"], k=5)
    # 상품을 안 가리킨 일반 질문(배송 등)은 섹션만 맞으면 맞은 것으로 본다 ―
    # 200개 상품의 배송 섹션이 글자까지 똑같아서 상품을 가리는 게 의미가 없다
    sections = [s["section"] for s in found]
    ranks = [(s["product_id"], s["section"]) for s in found]
    for k in hits:
        if (item["product_id"], item["section"]) in ranks[:k] or item["section"] in sections[:k]:
            hits[k] += 1
    if (item["product_id"], item["section"]) not in ranks and item["section"] not in sections:
        missed.append((item["id"], item["question"], item["section"], sections[:3]))

n = len(ITEMS)
print(f"  hit@1 {hits[1] / n * 100:.0f}%  ·  hit@3 {hits[3] / n * 100:.0f}%  "
      f"·  hit@5 {hits[5] / n * 100:.0f}%   ({n}문항)")

if missed:
    print(f"\n  못 찾은 것 {len(missed)}개 ― 왜 못 찾았는지가 수업 재료다:")
    for item_id, question, section, got in missed:
        print(f"      {item_id}. {question}")
        print(f"          정답 [{section}] · 검색 결과 {got}")