import os

os.makedirs("docs", exist_ok=True)

# """...""" 는 여러 줄 문자열이다. 줄바꿈을 \n 으로 적지 않고 그냥 엔터를 쳐서 넣는다.
files = {
    "backend.txt": """수업용 예제

백엔드 개발자는 서버와 데이터베이스를 다룬다. 사용자 눈에 보이지 않는 곳에서 데이터를 저장하고 꺼내는 일을 한다.

주로 쓰는 언어는 자바, 파이썬, 노드다. 회사마다 다르지만 하나를 깊게 아는 편이 여럿을 얕게 아는 것보다 낫다. 요즘은 클라우드 지식도 함께 요구된다. 서버를 직접 사는 회사가 줄었기 때문이다.

신입에게 가장 많이 물어보는 것은 데이터베이스다. 인덱스가 무엇인지, 조인이 왜 느려지는지를 설명할 수 있으면 절반은 됐다.""",

    "frontend.txt": """수업용 예제

프론트엔드 개발자는 사용자가 직접 보는 화면을 만든다. 버튼을 누르면 무슨 일이 일어나는지를 설계한다.

리액트와 뷰가 많이 쓰인다. 요즘은 타입스크립트를 같이 쓰는 곳이 대부분이다.

화면이 느리면 사용자가 바로 떠난다. 그래서 성능을 재는 방법을 아는 것이 중요하다.""",

    "data.txt": """수업용 예제

데이터 엔지니어는 흩어진 데이터를 모아 쓸 수 있는 형태로 만든다. 파이프라인이라고 부르는 흐름을 짠다.

파이썬과 SQL 을 쓴다. 데이터가 커지면 도구가 달라지지만 생각하는 방식은 같다.

수집한 데이터가 틀리면 그 뒤가 전부 틀린다. 그래서 검증에 시간을 많이 쓴다.""",
}

for name, content in files.items():
    with open(f"docs/{name}", "w", encoding="utf-8") as f:
        f.write(content)

# 빈 줄을 기준으로 자르면 문단이 나온다.
# "\n" 은 글자 두 개가 아니라 줄바꿈 하나를 뜻하는 표기다.
doc = files["backend.txt"]
paras = doc.split("\n\n")
print(len(doc), len(paras))

for i, p in enumerate(paras):
    # {p[:30]} - 중괄호 안에서 슬라이싱도 된다. 문단이 길어서 앞 30글자만 본다.
    print(f"{i}  ({len(p)}자)  {p[:30]}")

with open("docs/backend.txt", "r", encoding="utf-8") as f:
    doc = f.read()

paras = doc.split("\n\n")


def cut_once(text, size):
    """size 근처에서 문장이 끝나는 자리를 찾아 한 번 자른다. (앞, 뒤) 로 돌려준다."""
    if len(text) <= size:
        return text, ""                  # 자를 필요가 없다. 빈 문자열을 뒤로 준다

    window = text[:size]                 # 자를 후보 구간. 이 안에서만 찾는다
    cut = window.rfind(". ")             # 1. 문장 끝을 먼저 찾는다 - 제일 좋은 자리

    # or 는 "둘 중 하나라도 참이면".
    #   cut == -1        문장 끝이 아예 없다
    #   cut < size // 2  있긴 한데 너무 앞이다. // 는 몫만 남기는 나눗셈(60//2=30).
    if cut == -1 or cut < size // 2:
        cut = window.rfind(" ")          # 2. 단어 경계로 물러선다

    if cut == -1:                        # 3. 공백조차 없으면 (URL·코드 같은 것)
        cut = size                       #    어쩔 수 없이 글자 수로 자른다
    else:
        # rfind 는 찾은 것의 시작 위치를 준다. ". " 의 시작이 22면 마침표가 22번이다.
        # 23부터 잘라야 마침표가 앞 조각에 남는다.
        cut += 1

    # .strip() 은 앞뒤 공백을 없앤다. ". " 뒤에서 자르면 다음 조각이 공백으로 시작한다.
    return text[:cut].strip(), text[cut:].strip()


# 함수가 값 두 개를 돌려주므로 받는 이름도 두 개다. 순서대로 들어간다.
head, rest = cut_once(paras[2], 60)

print(f"앞  ({len(head)}자)  {head}")
print(f"뒤  ({len(rest)}자)  {rest}")

with open("docs/backend.txt", "r", encoding="utf-8") as f:
    doc = f.read()


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=60):
    """문단으로 나누고, 긴 문단은 문장 끝에서 자른다."""
    out = []
    # 컴프리헨션 안에서 두 가지를 한다 - 앞뒤 공백을 없애고(.strip()),
    # 그러고도 내용이 남는 것만 담는다(if p.strip()). 빈 문단이 걸러진다.
    for para in [p.strip() for p in text.split("\n\n") if p.strip()]:
        rest = para                      # 아직 안 자른 나머지
        # while 은 "조건이 참인 동안 반복". 문자열이 비면 거짓이 되어 멈춘다.
        while rest:
            head, rest = cut_once(rest, size)
            if not head:
                break                    # 안전장치 - 못 자르면 무한 반복이 된다
            out.append(head)
    return out


for i, c in enumerate(chunk_smart(doc)):
    print(f"{i}  ({len(c)}자)  {c}")

with open("docs/backend.txt", "r", encoding="utf-8") as f:
    doc = f.read()


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=60, min_size=20):
    """문단으로 나누고, 긴 문단은 문장 끝에서 자른다. 짧은 꼬리는 앞 조각에 붙인다."""
    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
            # and 는 "둘 다 참이어야".
            #   len(head) < min_size   너무 짧고
            #   and out                앞에 붙일 조각이 있어야 한다
            if len(head) < min_size and out:
                # out[-1] 은 마지막 항목이다 (2강의 음수 번호).
                # 사이에 공백 하나를 넣어야 단어가 붙어버리지 않는다.
                out[-1] = out[-1] + " " + head
            else:
                out.append(head)
    return out


for i, c in enumerate(chunk_smart(doc)):
    print(f"{i}  ({len(c)}자)  {c}")

# 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강에서 만든 것 - 11강에서 비교 대상으로 쓴다."""
    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):
    """문단으로 나누고, 긴 문단은 문장 끝에서 자른다. 짧은 꼬리는 앞에 붙인다."""
    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

import search

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

for c in chunks[:4]:
    print(f'{c["source"]:14s} ({len(c["text"])}자)  {c["text"][:34]}')