# ─────────────────────────────────────────────────────────────
# 3일차 ― 임베딩
# ─────────────────────────────────────────────────────────────

# 이 모델이 한 문장을 몇 개의 실수로 바꾸는가. 표를 만들 때와 점검할 때 쓴다
EMBED_DIM = 384

# 벡터를 문자로 적을 때 소수점 몇 자리까지 쓸까.
# 자릿수를 그대로 두면 파일이 두 배가 된다. 얼마나 손해인지는 5교시에 직접 잰다
EMBED_DECIMALS = 6

"""뜻을 숫자로 바꾼다. **이 파일도 DB 정보를 모른다.**

    들어오는 것   ["[비타민C 필링 로션 > 주의사항] 고농도...", ...]   ― 그냥 글 목록
    나가는 것     [[0.018827, -0.024955, ...], ...]                 ― 그냥 숫자 목록

임베딩기를 만드는 자리가 이 파일 하나뿐이다. 
부르는 쪽(03_embed.py)은 모델이 무엇인지 모른다. 6일차에 상용 API 로 갈아끼울 때 고치는 곳이 여기 한 군데뿐입니다.

숫자를 어떻게 **저장**할지는 이 파일이 정하지 않는다. 그건 storage.py에서 정해질 값입니다.
"""

import time

from app.core.config import EMBED_MODEL

_embeddings = None


def get_embeddings():
    """임베딩기를 한 번만 만들어 두고 계속 쓴다. 모델을 올리느라 몇 초 걸린다."""
    global _embeddings
    if _embeddings is not None:
        return _embeddings

    from langchain_huggingface import HuggingFaceEmbeddings

    _embeddings = HuggingFaceEmbeddings(
        model_name=EMBED_MODEL,
        model_kwargs={"device": "cpu"},
        encode_kwargs={"normalize_embeddings": True, "batch_size": 64},
    )
    return _embeddings


def embed_documents(texts):
    """글 목록을 벡터 목록으로. 돌려주는 것: (벡터 목록, 걸린 초)"""
    started = time.perf_counter()
    vectors = get_embeddings().embed_documents(texts)
    return vectors, time.perf_counter() - started

"""자료구조를 데이터베이스에 넣는다. **이 파일은 자르는 법을 모른다.**

스플리터도 임베딩기도 부르지 않는다. 이미 만들어진 것을 받아서 넣기만 한다.
"""

import json

from app.core.config import EMBED_DECIMALS, EMBED_MODEL


def vector_to_text(vector):
    """벡터를 '[0.018827,-0.024955,...]' 라는 **글자**로 바꾼다.

    소수점 6자리로 줄여 적는다 (config 의 EMBED_DECIMALS).
    """
    return json.dumps([round(x, EMBED_DECIMALS) for x in vector])

def save_vectors(con, kind, key, parent, ids, vectors, dim):
    """벡터 정보가 저장될 테이블을 하나를 만들고 저장한다. 앞으로 만들 4개의 데이터셋이 모두 이 함수로 벡터화되어 저장된다."""
    #  PK타입을 수동으로 입력하지 않고 부모 테이블에서 읽어 온다.
    #  chunks.chunk_id 는 INTEGER 고 products.product_id 는 TEXT 다.
    #  어긋나면 조인이 오류 없이 0건이 출력된다
    key_type = next(x[2] for x in con.execute(f"PRAGMA table_info({parent})") if x[1] == key)

    con.execute(f"DROP TABLE IF EXISTS {kind}_vectors")
    con.execute(f"""
        CREATE TABLE {kind}_vectors (
            {key}  {key_type} PRIMARY KEY,
            dim    INTEGER NOT NULL,
            model  TEXT NOT NULL,
            vector TEXT NOT NULL,
            FOREIGN KEY ({key}) REFERENCES {parent}({key})
        )
    """)
    con.executemany(
        f"INSERT INTO {kind}_vectors ({key}, dim, model, vector) VALUES (?, ?, ?, ?)",
        [(item_id, dim, EMBED_MODEL, vector_to_text(vector))
         for item_id, vector in zip(ids, vectors)],
    )
    con.commit()

"""글을 벡터로 만들어 넣는다 ― 총 4개의 카테고리 정보로 구성.

이 파일이 하는 일은 순서를 정하는 것뿐이다. 실제 일은 prep/ 안에서 한다.

 고객은 세 층으로 나눠 다룬다 .
       정형   나이 · 성별 · 지역     -> SQL 이 답한다. 벡터로 안 만든다
       취향   피부타입 · 카테고리     -> customer_vectors (한 명 = 한 점)
       본문   후기 1,200건          -> review_vectors (1건 = 1행)

이 파일은 비싸다. 로컬에서 30초쯤 걸리고 상용 API 를 켜면 해당 정보를 임베딩하는 모든 토큰비용이 곧 요금이다.
   그래서 02_chunk.py 와 갈라 뒀다. 조각을 안 바꿨으면 다시 돌릴 이유가 없다.

앞:    python pipeline/02_chunk.py
실행:  python pipeline/03_embed.py
"""

import sqlite3
import sys
import time
from collections import Counter
from pathlib import Path

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

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 app.core.config import DB_PATH, EMBED_DIM, EMBED_MODEL
from pipeline.prep import embedding, storage

con = sqlite3.connect(DB_PATH)
con.execute("PRAGMA foreign_keys = ON")


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

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}")


targets = {}

# ─ 상세 상품 정보 조각 ─ 이전 시간에 미리 벡터화 한 정보들
r = con.execute("SELECT chunk_id, text FROM chunks ORDER BY chunk_id").fetchall()
targets["chunk"] = ("chunk_id", "chunks", [x[0] for x in r], [x[1] for x in r])

# ─ 상품 정보 요약 한줄
r = con.execute("""
    SELECT product_id, name, brand, category, price, skin_type,
           ingredient, concern, tags, description
    FROM products ORDER BY product_id
""").fetchall()
targets["product"] = ("product_id", "products", [x[0] for x in r],
                      [product_text(x[1:]) for x in r])

# ─ 고객 정보 is_holdout = 1 은 뺀다. AI에게 일부러 정답을 제외해서 확증편향 방지 목적
history = {}
for cid, category, ingredient, concern, rating in con.execute("""
    SELECT purchases.customer_id, products.category, products.ingredient,
           products.concern, purchases.rating
    FROM purchases
    JOIN products ON products.product_id = purchases.product_id
    WHERE purchases.is_holdout = 0
    ORDER BY purchases.customer_id, purchases.purchase_id
"""):
    history.setdefault(cid, []).append((None, category, ingredient, concern, rating))

skin_of = dict(con.execute("SELECT customer_id, skin_type FROM customers"))
cids = [c for (c,) in con.execute("SELECT customer_id FROM customers ORDER BY customer_id")
        if c in history]
targets["customer"] = ("customer_id", "customers", cids,
                       [customer_text(skin_of[c], history[c]) for c in cids])

# ─ 고객후기만 분리 : 고객후기 한 건을 한 행으로 저장 (이어 붙이지 않는다)
r = con.execute("""
    SELECT purchase_id, review FROM purchases
    WHERE is_holdout = 0 AND review IS NOT NULL AND review != ''
    ORDER BY purchase_id
""").fetchall()
targets["review"] = ("purchase_id", "purchases", [x[0] for x in r], [x[1] for x in r])


# ═══════════════════════════════════════════════ ② 벡터로 만들어 넣는다
print(f"임베딩 ― {EMBED_MODEL}")

started = time.perf_counter()
embedding.get_embeddings()
print(f"  임베딩기 준비 {time.perf_counter() - started:.1f}초\n")

print(f"  {'무엇':10s} {'개수':>7s} {'평균 글자':>9s} {'걸린 시간':>10s} {'초당':>9s}")
for kind, (key, parent, ids, texts) in targets.items():
    vectors, elapsed = embedding.embed_documents(texts)

    dim = len(vectors[0])
    if dim != EMBED_DIM:
        print(f"  경고: config 의 EMBED_DIM({EMBED_DIM}) 과 실제 차원({dim}) 이 다르다")

    # 네 개의 데이터 카테고리를 같은 구조로 활용. 테이블 이름도 PK도 f-string 으로 갈아 끼우기 편하게 데이터 구조 통일
    storage.save_vectors(con, kind, key, parent, ids, vectors, dim)

    print(f"  {kind:10s} {len(ids):>7,} {sum(len(t) for t in texts) / len(texts):>9.0f} "
          f"{elapsed:>9.1f}초 {len(ids) / elapsed:>8.0f}개")

peek = con.execute("SELECT vector FROM product_vectors LIMIT 1").fetchone()[0]
print(f"\n  실제로 이렇게 들어 있다:\n    {peek[:60]}...")

sample = con.execute("SELECT customer_id FROM customer_vectors LIMIT 1").fetchone()[0]
print(f"\n  고객 한 명을 이렇게 적었다 ({sample}):")
print(f"    {targets['customer'][3][targets['customer'][2].index(sample)]}")
con.close()