import time

t = time.perf_counter()
from transformers import AutoTokenizer
print(f"  ① import (torch · transformers)  {time.perf_counter() - t:6.1f}초")

t = time.perf_counter()
tok = AutoTokenizer.from_pretrained("intfloat/multilingual-e5-small")
print(f"  ② 토크나이저 올리기               {time.perf_counter() - t:6.1f}초")

import sqlite3
con = sqlite3.connect("cosmetic.db")
details = [d for (d,) in con.execute("SELECT detail FROM product_details")]

t = time.perf_counter()
counts = [len(tok.encode(d)) for d in details]
print(f"  ③ 상세 200건 토큰 세기            {time.perf_counter() - t:6.1f}초")

from langchain_text_splitters import MarkdownHeaderTextSplitter

t = time.perf_counter()
splitter = MarkdownHeaderTextSplitter(headers_to_split_on=[("##", "section")])
sections = [doc for d in details for doc in splitter.split_text(d)]
print(f"  ④ 실제로 자르기                   {time.perf_counter() - t:6.1f}초  ({len(sections):,}조각)")

"""파이프라인 ― CSV 를 읽어서 검색할 수 있는 DB 로 만드는 자리."""

"""자르는 일과 넣는 일을 가른 자리.

    options.py    조절값. 실습에서 손대는 건 여기뿐이다
    chunking.py   순수. 글을 조각으로.     데이터베이스를 모른다
    storage.py    바깥. 자료구조를 DB 로.  자르는 법을 모른다

위 둘은 서로도 모른다. 셋을 순서대로 부르는 일은 pipeline/02_chunk.py 가 한다.
오늘 오후에 embedding.py 가 하나 더 들어온다.
"""

"""조각을 어떻게 자를지 정하는 값들 ― 실습에서 손대는 건 여기뿐이다.

이 파일을 따로 뗀 이유
    값을 바꿔 보는 실습을 할 때 240줄짜리 파일에서 여섯 줄을 찾아 헤매지 않는다.
    그리고 chunking.py 는 값이 바뀌어도 한 글자도 안 바뀐다 ― 그게 목적이다.
"""

from app.core.config import EMBED_MAX_TOKENS

CHUNK_SIZE = 384            # 조각 하나의 토큰 상한
CHUNK_OVERLAP = 48          # 경계에서 겹치는 몫
PREFIX_BUDGET = 32          # 접두어("[상품명 > 섹션]")가 쓸 토큰 자리

# 계산해서 잡는다. 상한이 바뀌면 문턱도 따라 움직인다 ― 손으로 두 번 적으면 한쪽만 고치게 된다
RESPLIT_OVER = EMBED_MAX_TOKENS - PREFIX_BUDGET

HEADERS = [("##", "section")]

SEPARATORS = ["\n\n", "\n", "다. ", "요. ", ". ", " ", ""]

"""긴 글을 조각으로 자른다. **이 파일은 데이터베이스를 모른다.**

    들어오는 것   [(상품번호, 상품명, 상세 원문), ...]   ― 그냥 파이썬 목록
    나가는 것     (섹션 목록, 조각 목록)                 ― 그냥 딕셔너리 목록

🔴 `import sqlite3` 이 없다. 커넥션도 안 받는다. 일부러 그렇다.
   그래서 이 파일은 DB 없이 시험할 수 있다.

자르는 순서는 어제와 같은 2단이다.
    1단  '## 주의사항' 같은 사람이 만든 경계로 자른다
    2단  그래도 상한을 넘는 것만 다시 자른다

조절값은 전부 options.py 에 있다. 이 파일에는 숫자가 없다.
"""

from langchain_text_splitters import (MarkdownHeaderTextSplitter,
                                      RecursiveCharacterTextSplitter)
from transformers import AutoTokenizer

from app.core.config import EMBED_TOKENIZER
from pipeline.prep.options import (CHUNK_OVERLAP, CHUNK_SIZE, HEADERS,
                                   RESPLIT_OVER, SEPARATORS)

_tokenizer = None


def get_tokenizer():
    """토큰을 세는 자. 무거우니 한 번만 올리고 계속 쓴다."""
    global _tokenizer
    if _tokenizer is None:
        _tokenizer = AutoTokenizer.from_pretrained(EMBED_TOKENIZER)
    return _tokenizer


def count_tokens(text):
    """토큰 수 (2일차 1교시)."""
    return len(get_tokenizer().encode(text))


def with_context(product_name, section, body):
    """[상품명 > 섹션] 본문 ― 접두어가 곧 문맥이다 (2일차 3교시)."""
    return f"[{product_name} > {section}] {body}"


def split_sections(details):
    """1단 ― 사람이 만든 경계로 자른다.

    🔴 어제와 달라진 것: 튜플이 아니라 **딕셔너리**를 돌려준다.
       storage.py 가 chunking.py 를 안 읽고도 무엇이 오는지 알아야 하기 때문이다.
    """
    splitter = MarkdownHeaderTextSplitter(headers_to_split_on=HEADERS)

    sections = []
    for product_id, product_name, detail in details:
        for doc in splitter.split_text(detail):
            text = doc.page_content.strip()
            if not text:
                continue
            sections.append({
                "product_id": product_id,
                "product_name": product_name,
                "section": doc.metadata.get("section", "(머리말)"),
                "text": text,
                "n_tokens": count_tokens(text),
            })
    return sections


def split_chunks(sections):
    """2단 ― 상한을 넘는 섹션만 다시 자르고, 접두어를 붙인다.

    body  접두어를 뺀 원문 조각   ― 화면에 띄울 때 쓴다
    text  접두어를 붙인 것        ― 임베딩에 넣는다
    """
    resplitter = RecursiveCharacterTextSplitter.from_huggingface_tokenizer(
        get_tokenizer(), chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP,
        separators=SEPARATORS, keep_separator="end")

    chunks, n_resplit = [], 0
    for section in sections:
        if section["n_tokens"] > RESPLIT_OVER:
            n_resplit += 1
            parts = resplitter.split_text(section["text"])
        else:
            parts = [section["text"]]

        for chunk_index, body in enumerate(parts):
            text = with_context(section["product_name"], section["section"], body)
            chunks.append({
                "product_id": section["product_id"],
                "product_name": section["product_name"],
                "section": section["section"],
                "chunk_index": chunk_index,
                "body": body,
                "text": text,
                "n_tokens": count_tokens(text),
            })
    return chunks, n_resplit


def split_details(details):
    """1단과 2단을 순서대로. 부르는 쪽은 이 하나만 알면 된다."""
    sections = split_sections(details)
    chunks, n_resplit = split_chunks(sections)
    return sections, chunks, n_resplit

>>> from pipeline.prep import chunking
>>> detail = "## 주의사항\n민감성 피부에는 사용을 권하지 않습니다."
>>> sections, chunks, n = chunking.split_details([("P001", "수분 크림", detail)])
>>> chunks[0]["text"]
'[수분 크림 > 주의사항] 민감성 피부에는 사용을 권하지 않습니다.'

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

스플리터를 부르지 않는다. 이미 만들어진 것을 받아서 넣기만 한다.
그래서 「조각이 이상하다」와 「저장이 이상하다」를 따로 볼 수 있다.

오늘 오후에 벡터 표를 만드는 함수가 여기 더 붙는다.
"""


def save_sections_and_chunks(con, sections, chunks):
    """섹션과 조각을 넣는다.

    🔴 커넥션을 밖에서 받는다. 이 함수는 sqlite3.connect() 를 부르지 않는다.
    """
    con.execute("DROP TABLE IF EXISTS chunk_vectors")
    con.execute("DROP TABLE IF EXISTS chunks")
    con.execute("DROP TABLE IF EXISTS sections")
    con.execute("""
        CREATE TABLE sections (
            section_id INTEGER PRIMARY KEY,
            product_id TEXT NOT NULL,
            section    TEXT NOT NULL,
            text       TEXT NOT NULL,
            n_tokens   INTEGER NOT NULL,
            FOREIGN KEY (product_id) REFERENCES products(product_id)
        )
    """)
    con.execute("""
        CREATE TABLE chunks (
            chunk_id    INTEGER PRIMARY KEY,
            section_id  INTEGER NOT NULL,
            product_id  TEXT NOT NULL,
            section     TEXT NOT NULL,
            chunk_index INTEGER NOT NULL,
            text        TEXT NOT NULL,
            body        TEXT NOT NULL,
            n_tokens    INTEGER NOT NULL,
            FOREIGN KEY (section_id) REFERENCES sections(section_id),
            FOREIGN KEY (product_id) REFERENCES products(product_id)
        )
    """)
    con.execute("CREATE INDEX idx_chunks_product_id ON chunks(product_id)")
    con.execute("CREATE INDEX idx_chunks_section ON chunks(section)")
    con.execute("CREATE INDEX idx_sections_product_id ON sections(product_id)")

    # 🔴 방금 붙은 번호를 담아 두는 보관함.
    #    cur.lastrowid 는 다음 INSERT 를 하면 사라진다. 나오는 그 자리에서 받아 둔다
    section_id_lookup = {}
    for section in sections:
        cur = con.execute(
            "INSERT INTO sections (product_id, section, text, n_tokens) VALUES (?, ?, ?, ?)",
            (section["product_id"], section["section"], section["text"], section["n_tokens"]),
        )
        section_id_lookup[(section["product_id"], section["section"])] = cur.lastrowid

    for chunk in chunks:
        con.execute("""
            INSERT INTO chunks (section_id, product_id, section, chunk_index, text, body, n_tokens)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        """, (section_id_lookup[(chunk["product_id"], chunk["section"])],
              chunk["product_id"], chunk["section"], chunk["chunk_index"],
              chunk["text"], chunk["body"], chunk["n_tokens"]))

    con.commit()

"""긴 상품 상세를 조각으로 자르고 저장한다.

🔴 이 파일에는 자르는 코드가 없다. prep/chunking.py 가 자르고, prep/storage.py 가
   넣는다. 이 파일은 둘을 순서대로 부르고 **숫자를 보여 준다.**
   조절값은 prep/options.py 한 곳에 있다.

🔴 벡터는 여기서 안 만든다. 03_embed.py 가 한다. 가른 이유는 값이다 ―
   조각을 다시 자르는 건 몇 초지만 벡터를 다시 만드는 건 로컬에서 30초쯤 걸리고,
   상용 API 를 켜 두면 그대로 요금이 된다.

앞:    python pipeline/01_schema.py
실행:  python pipeline/02_chunk.py
"""

import sqlite3
import statistics
import sys
from pathlib import Path

# pipeline/ 안에서 돌리는데 app/ 과 pipeline.prep 을 불러와야 한다. 그래서 뿌리를 경로에 넣는다
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_MAX_TOKENS, EMBED_TOKENIZER
from pipeline.prep import chunking, storage
from pipeline.prep.options import (CHUNK_OVERLAP, CHUNK_SIZE, PREFIX_BUDGET,
                                   RESPLIT_OVER)

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

ntok = chunking.count_tokens


def dist(values):
    """분포 한 줄 ― 최소 / 중앙 / 최대"""
    return (f"최소 {min(values):>5,} · 중앙 {int(statistics.median(values)):>5,} · "
            f"최대 {max(values):>5,}")


details = con.execute("""
    SELECT product_details.product_id, products.name, product_details.detail
    FROM product_details
    JOIN products ON product_details.product_id = products.product_id
    ORDER BY product_details.product_id
""").fetchall()

print(f"상품 상세 {len(details)}건을 읽었다\n")


# ═══════════════════════════════════════════════ ① 왜 자르나
print("=" * 74)
print("① 왜 자르나 ― 통째로 넣으면 뒤가 잘린다")
print("=" * 74)

full_tokens = [ntok(detail) for _, _, detail in details]
over = [n for n in full_tokens if n > EMBED_MAX_TOKENS]

print(f"  임베딩 모델 상한 : {EMBED_MAX_TOKENS} 토큰 ({EMBED_TOKENIZER})")
print(f"  상세 토큰 분포   : {dist(full_tokens)}")
print(f"  상한 초과        : {len(over)}/{len(full_tokens)}건 "
      f"({len(over) / len(full_tokens) * 100:.0f}%)\n")


# ═══════════════════════════════════════════════ ②③ 자른다
print("=" * 74)
print("② 2단 구조 ― 사람이 만든 경계로 자르고, 넘치는 것만 다시 자른다")
print("=" * 74)
print(f"  설정: CHUNK_SIZE {CHUNK_SIZE} · OVERLAP {CHUNK_OVERLAP} · "
      f"PREFIX_BUDGET {PREFIX_BUDGET} -> 다시 자를 문턱 {RESPLIT_OVER}")
print("  (prep/options.py 에 있다. 이 파일에는 숫자가 없다)\n")

# 🔴 이 한 줄이 자르기의 전부다. 어떻게 자르는지는 prep/chunking.py 가 안다
sections, chunks, n_resplit = chunking.split_details(details)

section_tokens = [section["n_tokens"] for section in sections]
chunk_tokens = [ntok(chunk["body"]) for chunk in chunks]
print(f"  {'':14s}{'개수':>8s}   분포")
print(f"  0단 (통째로)  {len(full_tokens):>8,}   {dist(full_tokens)}")
print(f"  1단 (섹션)    {len(sections):>8,}   {dist(section_tokens)}")
print(f"  2단 (조각)    {len(chunks):>8,}   {dist(chunk_tokens)}")
print(f"  다시 자른 섹션: {n_resplit}개 / {len(sections):,}개\n")

example = next(chunk for chunk in chunks if chunk["section"] == "주의사항")
print("③ 문맥 유지 ― 조각 앞에 제목과 섹션명을 붙인다")
print(f"  붙이기 전: {example['body'][:46]}...")
print(f"  붙인 뒤  : {example['text'][:46]}...\n")


# ═══════════════════════════════════════════════ ④ 저장
# 🔴 이 한 줄이 저장의 전부다. 어떻게 넣는지는 prep/storage.py 가 안다
storage.save_sections_and_chunks(con, sections, chunks)

stored = [n for (n,) in con.execute("SELECT n_tokens FROM chunks")]
print("=" * 74)
print("④ 저장 ― sections · chunks")
print("=" * 74)
print(f"  sections {len(sections):>6,}행")
print(f"  chunks   {len(chunks):>6,}행  ·  접두어까지 넣은 토큰 {dist(stored)}")
print(f"  상한({EMBED_MAX_TOKENS}) 초과: {sum(n > EMBED_MAX_TOKENS for n in stored)}개")
con.close()

"""같은 것을 두 번 찾지 않는다 ― 딕셔너리에 담아 두기 vs 매번 SELECT.

「왜 딕셔너리에 담아 두나. 그냥 필요할 때 SELECT 하면 되지 않나」
그 물음을 **재서** 답한다.

    (A) 조각마다 SELECT section_id FROM sections WHERE product_id=? AND section=?
    (B) 딕셔너리에 담아 두고 꺼내 쓴다

🔴 이 파일은 DB 를 **읽기만 한다.** 지워도 파이프라인이 돈다.

앞:    python pipeline/02_chunk.py
실행:  python pipeline/05_lookup_bench.py
"""

import sqlite3
import sys
import time
from pathlib import Path

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

from app.core.config import DB_PATH

con = sqlite3.connect(DB_PATH)

# 조각이 저장 모듈에 도착했을 때 들고 있는 것과 같은 모양 ― 자연키뿐이다
keys = con.execute("SELECT product_id, section FROM chunks ORDER BY chunk_id").fetchall()

print(f"조각 {len(keys):,}건에 대해 section_id 를 찾는다\n")

# ─────────────────────────────────────────────── (A) 매번 SELECT
started = time.perf_counter()
a_result = []
for product_id, section in keys:
    row = con.execute(
        "SELECT section_id FROM sections WHERE product_id = ? AND section = ?",
        (product_id, section)).fetchone()
    a_result.append(row[0])
a_elapsed = time.perf_counter() - started

# ─────────────────────────────────────────────── (B) 담아 두고 꺼내 쓰기
started = time.perf_counter()
section_id_lookup = {(product_id, section): section_id for section_id, product_id, section
                     in con.execute("SELECT section_id, product_id, section FROM sections")}
b_result = [section_id_lookup[key] for key in keys]
b_elapsed = time.perf_counter() - started

assert a_result == b_result, "두 방식의 답이 다르다. 재기 전에 이것부터 고쳐야 한다"

print(f"  (A) 조각마다 SELECT      {a_elapsed:>8.4f}초   (질의 {len(keys):,}번)")
print(f"  (B) 담아 두고 꺼내 쓰기   {b_elapsed:>8.4f}초   (질의 1번 + 딕셔너리 조회)")
print(f"  {a_elapsed / b_elapsed:>26.1f}배   ― 답은 {len(a_result):,}건 모두 같다")
con.close()