# search.py - 문서를 읽고 두 가지 방식으로 잘라 조각으로 만든다
import os
import glob


def load_documents(folder=None):
    """폴더 안 txt 를 전부 읽는다."""
    folder = folder or os.getenv("DOCS_DIR", "docs")
    paths = sorted(glob.glob(f"{folder}/*.txt"))

    if not paths:
        print(f"[경고] '{folder}' 에서 txt 파일을 못 찾았다.")
        return []

    result = []
    for path in paths:
        try:
            with open(path, "r", encoding="utf-8") as f:
                result.append({"source": os.path.basename(path), "text": f.read()})
        except UnicodeDecodeError:
            print(f"[건너뜀] {path} - utf-8 이 아니다")

    print(f"문서 {len(result)}건을 읽었다 (폴더: {folder})")
    return result


def chunk_text(text, size=200, overlap=30):
    """글자 수로만 자른다. 9강에서 만든 것."""
    if overlap >= size:
        raise ValueError(f"overlap({overlap})은 size({size})보다 작아야 한다")

    result = []
    step = size - overlap
    for start in range(0, len(text), step):
        piece = text[start:start + size]
        if piece:
            result.append(piece)
    return result


def cut_once(text, size):
    """size 근처에서 문장이 끝나는 자리를 찾아 한 번 자른다."""
    if len(text) <= size:
        return text, ""
    window = text[:size]
    cut = window.rfind(". ")
    if cut == -1 or cut < size // 2:
        cut = window.rfind(" ")
    if cut == -1:
        cut = size
    else:
        cut += 1
    return text[:cut].strip(), text[cut:].strip()


def chunk_smart(text, size=200, min_size=60):
    """문단으로 나누고, 긴 문단은 문장 끝에서 자른다. 10강에서 만든 것."""
    out = []
    for para in [p.strip() for p in text.split("\n\n") if p.strip()]:
        rest = para
        while rest:
            head, rest = cut_once(rest, size)
            if not head:
                break
            if len(head) < min_size and out:
                out[-1] = out[-1] + " " + head
            else:
                out.append(head)
    return out


def build_chunks(folder=None, size=200, min_size=60):
    """문단+문장 방식으로 조각을 만든다."""
    chunks = []
    for doc in load_documents(folder):
        for piece in chunk_smart(doc["text"], size, min_size):
            if piece.strip():
                chunks.append({"source": doc["source"], "text": piece})
    return chunks


def build_chunks_plain(folder=None, size=200, overlap=30):
    """글자 수로만 자른다. 문단+문장 방식과 비교하려고 남겨둔다."""
    chunks = []
    for doc in load_documents(folder):
        # 9강에서 만든 chunk_text 를 쓴다. build_chunks 는 10강의 chunk_smart 를 쓴다.
        # 부르는 함수 하나만 다르고 나머지는 같다.
        for piece in chunk_text(doc["text"], size, overlap):
            if piece.strip():           # 공백뿐인 조각은 버린다
                chunks.append({"source": doc["source"], "text": piece})
    return chunks

# 소괄호 ( ) 로 묶은 것이 튜플이다. 리스트와 거의 같은데 한 번 만들면 못 바꾼다.
# 이름을 대문자로 쓴 것은 "이건 고정값"이라는 관례다. 문법이 아니라 약속이다.
QUESTIONS = [
    ("인덱스가 뭔지 물어본다",        "backend.txt"),   # (질문, 답이 있는 파일)
    ("화면이 느리면 어떻게 되나",      "frontend.txt"),
    ("데이터가 틀리면 어떻게 되나",    "data.txt"),
    ("타입스크립트를 쓰나",           "frontend.txt"),
    ("파이프라인을 짜는 일",          "data.txt"),
    ("서버와 데이터베이스를 다루는 일", "backend.txt"),
]

print(len(QUESTIONS))
print(QUESTIONS[0])
print(QUESTIONS[0][0], "->", QUESTIONS[0][1])

import search

QUESTIONS = [
    ("인덱스가 뭔지 물어본다",        "backend.txt"),
    ("화면이 느리면 어떻게 되나",      "frontend.txt"),
    ("데이터가 틀리면 어떻게 되나",    "data.txt"),
    ("타입스크립트를 쓰나",           "frontend.txt"),
    ("파이프라인을 짜는 일",          "data.txt"),
    ("서버와 데이터베이스를 다루는 일", "backend.txt"),
]


def score(query, text):
    """질문 글자 중 몇 %가 조각 안에 들어 있는지 센다."""
    hit = 0
    for ch in query:
        if ch in text:
            hit += 1
    return hit / len(query)


def rank_of_answer(chunks, query, answer_file):
    """정답 문서에서 나온 조각이 몇 위에 오는지 돌려준다."""
    # 3강의 정렬 그대로다. 달라진 건 text 대신 source 를 담는다는 것뿐이다.
    ranked = sorted(
        [{"score": score(query, c["text"]), "source": c["source"]} for c in chunks],
        key=lambda r: r["score"],
        reverse=True,
    )
    # enumerate 는 0부터 세는데 순위는 1부터다. start=1 하나로 해결된다.
    for i, r in enumerate(ranked, start=1):
        if r["source"] == answer_file:
            return i                    # return 을 만나면 함수가 그 자리에서 끝난다
    # 정답 문서 조각이 하나도 없는 경우다.
    # 없는 걸 0이나 -1로 돌려주면 평균을 낼 때 조용히 결과를 왜곡한다.
    return len(ranked) + 1


chunks = search.build_chunks(size=60, min_size=20)
print(len(chunks))

for q, a in QUESTIONS:
    print(rank_of_answer(chunks, q, a), q)

import search

QUESTIONS = [
    ("인덱스가 뭔지 물어본다",        "backend.txt"),
    ("화면이 느리면 어떻게 되나",      "frontend.txt"),
    ("데이터가 틀리면 어떻게 되나",    "data.txt"),
    ("타입스크립트를 쓰나",           "frontend.txt"),
    ("파이프라인을 짜는 일",          "data.txt"),
    ("서버와 데이터베이스를 다루는 일", "backend.txt"),
]


def score(query, text):
    hit = 0
    for ch in query:
        if ch in text:
            hit += 1
    return hit / len(query)


def rank_of_answer(chunks, query, answer_file):
    ranked = sorted(
        [{"score": score(query, c["text"]), "source": c["source"]} for c in chunks],
        key=lambda r: r["score"],
        reverse=True,
    )
    for i, r in enumerate(ranked, start=1):
        if r["source"] == answer_file:
            return i
    return len(ranked) + 1


# 튜플 (이름, 조각목록) 세 개를 리스트에 담는다.
cases = [
    ("글자수 60 · 겹침 0",  search.build_chunks_plain(size=60, overlap=0)),
    ("글자수 60 · 겹침 15", search.build_chunks_plain(size=60, overlap=15)),
    ("문단+문장 60",        search.build_chunks(size=60, min_size=20)),
]

print("---")

# 튜플이 들어 있으니 받는 이름도 두 개다 - name 에 이름, chunks 에 조각 목록.
for name, chunks in cases:
    ranks = [rank_of_answer(chunks, q, a) for q, a in QUESTIONS]

    # sum(1 for ... if 조건) 은 "조건에 맞는 것이 몇 개인가"를 세는 흔한 표현이다.
    top1 = sum(1 for r in ranks if r == 1)
    avg = sum(ranks) / len(ranks)

    # {name:18s} 는 "문자열을 18칸에 왼쪽 맞춤". 세로로 줄이 맞는다.
    print(f"{name:18s} 조각 {len(chunks):2d}개  1위 {top1}/{len(QUESTIONS)}  평균 {avg:.2f}  {ranks}")

import search


def score(query, text):
    hit = 0
    for ch in query:
        if ch in text:
            hit += 1
    return hit / len(query)


chunks = search.build_chunks(size=60, min_size=20)
query = "화면이 느리면 어떻게 되나"      # 정답은 frontend.txt

# 이번엔 순위만이 아니라 점수·길이·원문까지 봐야 해서 딕셔너리에 셋을 담는다.
ranked = sorted(
    [{"s": score(query, c["text"]), "src": c["source"], "t": c["text"]} for c in chunks],
    key=lambda r: r["s"],
    reverse=True,
)

for i, r in enumerate(ranked[:4], start=1):     # 위에서 4개만
    print(f'{i}위 {r["s"]:.2f}  {len(r["t"]):2d}자  {r["src"]:14s} {r["t"][:32]}')

import search


def score(query, text):
    hit = 0
    for ch in query:
        if ch in text:
            hit += 1
    return hit / len(query)


chunks = search.build_chunks(size=60, min_size=20)
query = "화면이 느리면 어떻게 되나"

# (길이, 점수) 튜플을 만들어 정렬한다.
# 튜플을 정렬하면 앞 항목부터 비교하므로, 길이 순으로 줄이 선다.
# key= 를 안 줘도 되는 경우다 - 무엇으로 비교할지가 이미 정해져 있다.
rows = sorted([(len(c["text"]), score(query, c["text"])) for c in chunks])

for n, s in rows:       # 튜플이 두 칸이니 받는 이름도 두 개
    print(f"{n:2d}자  ->  {s:.2f}")