from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
)
chunks = splitter.split_documents(docs)

from langchain_chroma import Chroma
from langchain_ollama import OllamaEmbeddings
# 또는 from langchain_openai import OpenAIEmbeddings

embeddings = OllamaEmbeddings(model="bge-m3")  # 로컬 임베딩 모델 예시

vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",   # 로컬 영속 저장
    collection_name="my_docs",
)

# 1) 단순 유사도 검색
results = vectorstore.similarity_search(query, k=4)

# 2) 점수 포함 검색
results_with_score = vectorstore.similarity_search_with_score(query, k=4)

# 3) Retriever로 변환 (체인에 연결하기 위한 표준 인터페이스)
retriever = vectorstore.as_retriever(
    search_type="similarity",       # "mmr" 등도 가능
    search_kwargs={"k": 4},
)

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_ollama import ChatOllama

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

prompt = ChatPromptTemplate.from_template("""
다음 컨텍스트를 바탕으로 질문에 답하세요. 컨텍스트에 없는 내용은 모른다고 답하세요.

[컨텍스트]
{context}

[질문]
{question}
""")

llm = ChatOllama(model="exaone3.5:7.8b", temperature=0)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("질문 내용")

retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 검색만 단독 실행
retrieved_docs = retriever.invoke("질문")

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.chains import create_history_aware_retriever, create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain

# 1) 대화 맥락 반영해 질문 재구성하는 retriever
contextualize_prompt = ChatPromptTemplate.from_messages([
    ("system", "이전 대화를 참고하여 질문을 독립적으로 이해 가능한 형태로 재작성하세요."),
    MessagesPlaceholder("chat_history"),
    ("human", "{input}"),
])
history_aware_retriever = create_history_aware_retriever(llm, retriever, contextualize_prompt)

# 2) 답변 생성 체인
qa_prompt = ChatPromptTemplate.from_messages([
    ("system", "다음 컨텍스트를 바탕으로 답하세요.\n\n{context}"),
    MessagesPlaceholder("chat_history"),
    ("human", "{input}"),
])
qa_chain = create_stuff_documents_chain(llm, qa_prompt)

rag_chat_chain = create_retrieval_chain(history_aware_retriever, qa_chain)

# 웹페이지 로더 임포트
from langchain_community.document_loaders import WebBaseLoader

# 가져올 웹페이지 URL 지정
url = "https://namu.wiki/w/%EC%9E%84%ED%8E%98%EB%A6%AC%EC%96%BC%20%EC%B9%BC%EB%A6%AC%EC%A7%80%20%EB%9F%B0%EB%8D%98"
loader = WebBaseLoader(url)

# 웹페이지를 문서(Document) 객체 리스트로 로드
docs = loader.load()

# 첫 번째 문서의 본문 텍스트 출력
print(docs[0].page_content)

# 웹페이지 로더와 텍스트 스플리터 임포트
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# 가져올 웹페이지 URL 지정
url = "https://namu.wiki/w/%EC%9E%84%ED%8E%98%EB%A6%AC%EC%96%BC%20%EC%B9%BC%EB%A6%AC%EC%A7%80%20%EB%9F%B0%EB%8D%98"
loader = WebBaseLoader(url)

# 웹페이지를 문서(Document) 객체 리스트로 로드
docs = loader.load()

# 청크 크기 500, 겹치는 구간 200으로 스플리터 설정
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=200)
print(text_splitter)

# 로드한 문서를 청크 단위로 분할
splited_docs = text_splitter.split_documents(docs)

# 전체 청크 개수 확인
print(len(splited_docs))

# 11번째 청크(인덱스 10)의 내용 출력
print(splited_docs[10].page_content)

"""
Context language : Korean
Embedding Model : Ollama / bge-m3 (한국어 특화)
"""
# 웹페이지 가져오기 -> 청크 나누기 -> 임베딩하여 ChromaDB에 저장 -> 의미기반 검색하기
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma

# 뉴스 기사 URL 지정
url = "https://n.news.naver.com/mnews/article/016/0002688935"
loader = WebBaseLoader(url)

# 웹페이지를 문서(Document) 객체 리스트로 로드
docs = loader.load()

# 청크 크기 1000, 겹치는 구간 200으로 분할
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splited_docs = text_splitter.split_documents(docs)

# 청크를 임베딩하여 벡터화 후 ChromaDB에 저장
from langchain_ollama import OllamaEmbeddings
vectorstore = Chroma.from_documents(
    documents=splited_docs,
    embedding=OllamaEmbeddings(
        model="bge-m3",
        base_url="http://127.0.0.1:11434"
    ),
    collection_name='ollama-kr'
)

# 질문과 의미적으로 유사한 청크 검색
docs = vectorstore.similarity_search("엔비디아 올해 실적 찾아줘")

# 질문과 관련된 chunk를 반환
# Chroma는 k=4가 디폴트 값이니 4개의 chunk를 반환
print(len(docs))
for i in range(len(docs)):
    print(docs[i].page_content)
    print("=" * 80)

"""
OpenAI는 임베딩과 채팅 모델의 성능 자체가 워낙 우수해서 RAG 없이도 어느정도 답변을 잘 하기 때문에
Ollama로 연습하는 것을 추천. 하지만 OpenAI의 자원들의 사용법 정도만 익히고 가면 좋을 것 같음.
"""
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_ollama import ChatOllama, OllamaEmbeddings

# 테스트할 네이버 뉴스 기사 URL 지정
url = "https://n.news.naver.com/mnews/article/008/0005405374"

# 웹페이지를 문서(Document) 객체 리스트로 로드
loader = WebBaseLoader(url)
docs = loader.load()

# 청크 크기 1000, 겹치는 구간 200으로 분할
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splited_docs = text_splitter.split_documents(docs)

# 청크를 임베딩하여 벡터화 후 ChromaDB에 저장
vectorstore = Chroma.from_documents(
    documents=splited_docs,
    embedding=OllamaEmbeddings(
        model="bge-m3",
        base_url='http://localhost:11434'
    ),
    collection_name='ollama-kr'
)

# 검색된 컨텍스트와 질문을 삽입할 프롬프트 템플릿 정의
prompt_template = """
질문은 다음 내용을 기본으로 하고 있어 : {context}

질문 : {question}
"""
prompt = ChatPromptTemplate.from_template(prompt_template)

# 답변 생성에 사용할 로컬 LLM 설정
llm = ChatOllama(
    model="exaone3.5:7.8b",
    base_url="http://localhost:11434",
    temperature=0,
    repeat_penalty=1.3
)

# 벡터스토어를 검색기(retriever)로 변환
retriever = vectorstore.as_retriever()

# 검색된 청크들을 하나의 문자열로 합치는 함수
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# RAG 체인 구성: 질문 -> 검색(retriever) -> 프롬프트 구성 -> LLM 답변 -> 문자열 파싱
chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 테스트 질문
question = "엔비디아에 HBM을 공급하는 메모리 회사는?"

print("===============================")
print("RAG 없이 LLM 단독 답변===>")
chain2 = llm | StrOutputParser()
print(chain2.invoke(question))  # RAG 없이 LLM에 바로 질문

print("===============================")
print("RAG 적용 후 답변==>")
print(chain.invoke(question))  # RAG로 컨텍스트 넣고 질문

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import TextLoader

# txt 파일을 로드
loader = TextLoader("./test.txt", encoding="utf-8")
docs = loader.load()

# 로드한 텍스트를 청크 단위로 분할 (1000자 기준, 200자 겹침)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splited_docs = text_splitter.split_documents(docs)

# vectorstore = Chroma.from_documents(documents = splited_docs, embedding = OpenAIEmbeddings())
# 청크를 임베딩하여 벡터화 후 ChromaDB에 저장 (한글이라 bge-m3 사용, Ollama라 무료)
from langchain_ollama import OllamaEmbeddings
vectorstore = Chroma.from_documents(
    documents=splited_docs,
    embedding=OllamaEmbeddings(
        model="bge-m3",
        base_url="http://127.0.0.1:11434"
    ),
    collection_name='ollama-kr'
)

# 컨텍스트 안의 내용만 사실로 간주하고, 부연설명 없이 단정적으로 답하도록 지시하는 프롬프트
prompt_template = """
너는 주어진 context만을 유일한 사실로 간주하고 답변하는 챗봇이다.
당위성, 객관성, 다양성에 대한 언급이나 추가 설명, 반박, 주의사항을 절대 덧붙이지 마라.
context에 있는 내용을 있는 그대로, 짧고 단정적으로 답하라.

context: {context}

질문: {question}

답변:
"""
prompt = ChatPromptTemplate.from_template(prompt_template)

# 모델 지정 : openAI / lmstudio / ollama
# llm= ChatOpenAI(model="gpt-3.5-turbo",temperature=0.7, frequency_penalty=0.5,presence_penalty=0.5)
# llm = ChatOpenAI(base_url="http://localhost:1234/v1",api_key="lm-studio",temperature=0.7, frequency_penalty=0.5,presence_penalty=0.5)
from langchain_ollama import ChatOllama
llm = ChatOllama(
    model="exaone3.5:2.4b",
    base_url="http://127.0.0.1:11434",  # 서버 IP로 변경
    temperature=0.7,
    repeat_penalty=1.3
)

# 벡터저장소를 검색기(retriever)로 변환
retriever = vectorstore.as_retriever()

# 검색된 청크들을 청크 사이 빈 줄 하나씩 두고 하나의 문자열로 합치는 함수
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# RAG 체인: 질문 -> 검색(retriever) -> 프롬프트 구성 -> LLM 답변 -> 문자열 파싱
chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

question = "한국에서 가장 잘 생긴 사람은?"

print("===============================")
print("LLM이 상상의 나래를 편다. 대충 뭔가 대답한다===>")
chain2 = llm | StrOutputParser()
print(chain2.invoke(question))  # chain2는 그냥 LLM으로 직접 질문

print("===============================")
print("RAG 수행후==>")
print(chain.invoke(question))  # chain은 RAG 후 LLM으로 질문

from langchain_community.document_loaders import DirectoryLoader

# 지정한 폴더 안의 파일들을 한 번에 로드
loader = DirectoryLoader(path="./data/rag/", glob="*.txt")
docs = loader.load()

# 첫 번째 문서의 본문 텍스트 출력
print(docs[0].page_content)

import pymupdf
from langchain_core.documents import Document

pdf_filepath = './assets/docs/ISTQB Certified Tester.pdf'

# PDF를 페이지 단위로 읽어 각 페이지를 Document 객체로 변환
def load_pdf(path):
    doc = pymupdf.open(path)
    docs = []
    for i, page in enumerate(doc):  # type: ignore
        text = page.get_text()
        if text.strip():
            docs.append(Document(page_content=text, metadata={"source": path, "page": i}))
    doc.close()
    return docs

pages = load_pdf(pdf_filepath)

len(pages)

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.documents import Document
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma  # 벡터DB
from langchain_openai import OpenAIEmbeddings
from langchain_ollama import ChatOllama

import pymupdf
import glob

# 지정 폴더의 모든 PDF 파일 경로를 수집
pdf_paths = glob.glob("./assets/docs/kopodoc/*.pdf")

# PyMuPDF로 PDF 페이지별 텍스트를 추출해 Document로 변환
def load_pdf(path):
    doc = pymupdf.open(path)
    docs = []
    for i, page in enumerate(doc):  # type: ignore
        text = page.get_text()
        if text.strip():
            docs.append(Document(page_content=text, metadata={"source": path, "page": i}))
    doc.close()
    return docs

# 폴더 내 모든 PDF를 읽어 하나의 문서 리스트로 합침
documents = []
for path in pdf_paths:
    print("===>", path)
    documents.extend(load_pdf(path))

# 청크 단위로 분할 (1000자 기준, 200자 겹침)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splited_docs = text_splitter.split_documents(documents)

# 청크를 임베딩해 벡터DB(Chroma)에 저장 (OpenAI 임베딩 사용)
vectorstore = Chroma.from_documents(
    documents=splited_docs,
    embedding=OpenAIEmbeddings(model="text-embedding-3-large"),
    collection_name='openai'
)

# 검색된 컨텍스트와 질문을 넣을 프롬프트 템플릿
prompt_template = """
질문은 다음 내용을 기본으로 하고 있어 : {context}

질문 : {question}
"""
prompt = ChatPromptTemplate.from_template(prompt_template)

# 답변 생성용 모델 (규정 기반 답변이라 temperature 0으로 고정)
llm = ChatOllama(
    model="exaone3.5:7.8b",
    temperature=0
)

# 벡터저장소를 검색기(retriever)로 변환
retriever = vectorstore.as_retriever()

# 검색된 청크들을 하나의 문자열로 합치는 함수
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

# RAG 체인: 질문 -> 검색(retriever) -> 프롬프트 구성 -> LLM 답변 -> 문자열 파싱
chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt | llm | StrOutputParser()
)

print("===============================")
print(" 나는 한국폴리텍대학의 다음을 학습한 인공지능이야 \n 1.학사운영규칙 \n 2.학칙 \n 3.대학요람")
print("===============================")

# 빈 입력이면 종료, 그 외에는 질문마다 RAG 체인으로 답변 반복
while True:
    question = input("나 => ")
    if question == "":
        print("=== 종료 ===")
        break
    print("AI =>", chain.invoke(question))  # chain은 RAG 후 LLM으로 질문
    print("===============================")

pdf_paths = glob.glob("./assets/docs/kopodoc/*.pdf")

documents = []
for path in pdf_paths:
    print("===>", path)
    documents.extend(load_pdf(path))

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
splited_docs = text_splitter.split_documents(documents)

vectorstore = Chroma.from_documents(
    documents=splited_docs,
    embedding=OpenAIEmbeddings(model="text-embedding-3-large"),
    collection_name='openai'
)

prompt_template = """
질문은 다음 내용을 기본으로 하고 있어 : {context}

질문 : {question}
"""
prompt = ChatPromptTemplate.from_template(prompt_template)

llm = ChatOllama(model="exaone3.5:7.8b", temperature=0)

retriever = vectorstore.as_retriever()

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt | llm | StrOutputParser()
)

while True:
    question = input("나 => ")
    if question == "":
        print("=== 종료 ===")
        break
    print("AI =>", chain.invoke(question))
    print("===============================")

"""
한국폴리텍대학 RAG 챗봇 - PyQt6 GUI 버전

기존 콘솔(input/print) 기반 RAG 챗봇을 PyQt6 GUI로 포팅한 버전.
- PDF 인덱싱(임베딩)은 시작 시 백그라운드 스레드에서 1회 수행 (GUI 멈춤 방지)
- 질문에 대한 LLM 답변도 백그라운드 스레드에서 처리 (GUI 멈춤 방지)
"""

import sys
import glob

from PyQt6.QtCore import Qt, QThread, pyqtSignal
from PyQt6.QtGui import QFont, QTextCursor, QTextDocument
from PyQt6.QtWidgets import (
    QApplication,
    QMainWindow,
    QWidget,
    QVBoxLayout,
    QHBoxLayout,
    QTextEdit,
    QLineEdit,
    QPushButton,
    QLabel,
    QProgressBar,
)

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.documents import Document
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_ollama import ChatOllama

import pymupdf

# ------------------------------------------------------------------
# 설정값 - 필요에 맞게 수정
# ------------------------------------------------------------------
PDF_GLOB_PATTERN = "./assets/docs/kopodoc/*.pdf"
EMBEDDING_MODEL = "text-embedding-3-large"
LLM_MODEL = "exaone3.5:7.8b"
CHROMA_COLLECTION_NAME = "openai"

PROMPT_TEMPLATE = """
질문은 다음 내용을 기본으로 하고 있어 : {context}

질문 : {question}
"""

WELCOME_TEXT = (
    "나는 한국폴리텍대학의 다음을 학습한 인공지능이야\n"
    "1. 학사운영규칙\n"
    "2. 학칙\n"
    "3. 대학요람"
)

# ------------------------------------------------------------------
# PyMuPDF로 PDF에서 페이지별 텍스트 추출 (unstructured 의존성 회피)
# ------------------------------------------------------------------
def load_pdf(path: str) -> list[Document]:
    doc = pymupdf.open(path)
    docs = []
    for i, page in enumerate(doc):  # type: ignore
        text = page.get_text()
        if text.strip():
            docs.append(Document(page_content=text, metadata={"source": path, "page": i}))
    doc.close()
    return docs

def format_docs(docs: list[Document]) -> str:
    return "\n\n".join(doc.page_content for doc in docs)

# ------------------------------------------------------------------
# 백그라운드 스레드 1: 인덱싱(PDF 로드 -> 청크 분할 -> 임베딩 -> 체인 구성)
# ------------------------------------------------------------------
class IndexingWorker(QThread):
    progress = pyqtSignal(str)          # 진행 상황 텍스트
    finished_ok = pyqtSignal(object)    # 완료 시 chain 객체 전달
    failed = pyqtSignal(str)            # 실패 시 에러 메시지 전달

    def run(self):
        try:
            pdf_paths = glob.glob(PDF_GLOB_PATTERN)
            if not pdf_paths:
                self.failed.emit(f"PDF 파일을 찾을 수 없습니다: {PDF_GLOB_PATTERN}")
                return

            documents = []
            for path in pdf_paths:
                self.progress.emit(f"로딩 중... {path}")
                documents.extend(load_pdf(path))

            self.progress.emit("청크 분할 중...")
            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
            splited_docs = text_splitter.split_documents(documents)

            self.progress.emit(f"임베딩 및 벡터DB 구축 중... (청크 {len(splited_docs)}개)")
            vectorstore = Chroma.from_documents(
                documents=splited_docs,
                embedding=OpenAIEmbeddings(model=EMBEDDING_MODEL),
                collection_name=CHROMA_COLLECTION_NAME,
            )

            prompt = ChatPromptTemplate.from_template(PROMPT_TEMPLATE)
            llm = ChatOllama(model=LLM_MODEL, temperature=0)
            retriever = vectorstore.as_retriever()

            chain = (
                {"context": retriever | format_docs, "question": RunnablePassthrough()}
                | prompt
                | llm
                | StrOutputParser()
            )

            self.progress.emit("준비 완료!")
            self.finished_ok.emit(chain)

        except Exception as e:
            self.failed.emit(str(e))

# ------------------------------------------------------------------
# 백그라운드 스레드 2: 질문 하나에 대한 chain.invoke 실행
# ------------------------------------------------------------------
class QueryWorker(QThread):
    finished_ok = pyqtSignal(str)
    failed = pyqtSignal(str)

    def __init__(self, chain, question: str):
        super().__init__()
        self.chain = chain
        self.question = question

    def run(self):
        try:
            answer = self.chain.invoke(self.question)
            self.finished_ok.emit(answer)
        except Exception as e:
            self.failed.emit(str(e))

# ------------------------------------------------------------------
# 메인 윈도우
# ------------------------------------------------------------------
class ChatWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.chain = None
        self.indexing_worker = None
        self.query_worker = None

        self.setWindowTitle("한국폴리텍대학 RAG 챗봇")
        self.resize(700, 800)

        self._build_ui()
        self._start_indexing()

    # -- UI 구성 --------------------------------------------------
    def _build_ui(self):
        central = QWidget()
        self.setCentralWidget(central)
        layout = QVBoxLayout(central)

        # 상태 표시줄 (인덱싱 진행 상황)
        self.status_label = QLabel("초기화 중...")
        self.status_label.setStyleSheet("color: gray;")
        layout.addWidget(self.status_label)

        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 0)  # 인디터미네이트(빙글빙글) 모드
        layout.addWidget(self.progress_bar)

        # 채팅 표시 영역
        self.chat_view = QTextEdit()
        self.chat_view.setReadOnly(True)
        self.chat_view.setFont(QFont("맑은 고딕", 11))
        layout.addWidget(self.chat_view, stretch=1)

        # 입력 영역
        input_layout = QHBoxLayout()
        self.input_line = QLineEdit()
        self.input_line.setPlaceholderText("질문을 입력하세요...")
        self.input_line.returnPressed.connect(self._on_send)
        self.input_line.setEnabled(False)  # 인덱싱 끝나기 전엔 입력 불가
        input_layout.addWidget(self.input_line)

        self.send_button = QPushButton("전송")
        self.send_button.clicked.connect(self._on_send)
        self.send_button.setEnabled(False)
        input_layout.addWidget(self.send_button)

        layout.addLayout(input_layout)

        self._append_system_message(WELCOME_TEXT)

    # -- 인덱싱 시작 -----------------------------------------------
    def _start_indexing(self):
        self.indexing_worker = IndexingWorker()
        self.indexing_worker.progress.connect(self._on_indexing_progress)
        self.indexing_worker.finished_ok.connect(self._on_indexing_finished)
        self.indexing_worker.failed.connect(self._on_indexing_failed)
        self.indexing_worker.start()

    def _on_indexing_progress(self, message: str):
        self.status_label.setText(message)

    def _on_indexing_finished(self, chain):
        self.chain = chain
        self.status_label.setText("준비 완료 - 질문을 입력하세요")
        self.progress_bar.hide()
        self.input_line.setEnabled(True)
        self.send_button.setEnabled(True)
        self.input_line.setFocus()

    def _on_indexing_failed(self, error_message: str):
        self.status_label.setText("인덱싱 실패")
        self.progress_bar.hide()
        self._append_system_message(f"[오류] 인덱싱 중 문제가 발생했습니다:\n{error_message}")

    # -- 질문 전송 ---------------------------------------------------
    def _on_send(self):
        question = self.input_line.text().strip()
        if not question or self.chain is None:
            return

        self._append_user_message(question)
        self.input_line.clear()

        # 답변 대기 중 입력 잠금
        self.input_line.setEnabled(False)
        self.send_button.setEnabled(False)
        self.status_label.setText("답변 생성 중...")

        self.query_worker = QueryWorker(self.chain, question)
        self.query_worker.finished_ok.connect(self._on_answer_ready)
        self.query_worker.failed.connect(self._on_answer_failed)
        self.query_worker.start()

    def _on_answer_ready(self, answer: str):
        self._append_ai_message(answer)
        self.status_label.setText("준비 완료 - 질문을 입력하세요")
        self.input_line.setEnabled(True)
        self.send_button.setEnabled(True)
        self.input_line.setFocus()

    def _on_answer_failed(self, error_message: str):
        self._append_system_message(f"[오류] 답변 생성 실패:\n{error_message}")
        self.status_label.setText("준비 완료 - 질문을 입력하세요")
        self.input_line.setEnabled(True)
        self.send_button.setEnabled(True)

    # -- 채팅창에 메시지 추가 ------------------------------------------
    def _append_user_message(self, text: str):
        self.chat_view.append(f"<p style='color:#1a73e8;'><b>나 ▶</b> {self._escape(text)}</p>")
        self._scroll_to_bottom()

    def _append_ai_message(self, text: str):
        # QTextDocument의 markdown 렌더러로 raw markdown -> HTML 변환
        html_body = self._markdown_to_html(text)
        self.chat_view.append(f"<div style='color:#0b8043;'><b>AI ▶</b></div>{html_body}")
        self._scroll_to_bottom()

    @staticmethod
    def _markdown_to_html(markdown_text: str) -> str:
        # 임시 QTextDocument를 이용해 markdown을 HTML로 변환
        # (QTextEdit.setMarkdown()은 문서 전체를 덮어써서 append 방식과 안 맞으므로
        #  별도 QTextDocument에서 변환만 하고 결과 HTML만 추출해서 사용)
        temp_doc = QTextDocument()
        temp_doc.setMarkdown(markdown_text)
        return temp_doc.toHtml()

    def _append_system_message(self, text: str):
        formatted = self._escape(text).replace("\n", "<br>")
        self.chat_view.append(f"<p style='color:gray;'>{formatted}</p>")
        self._scroll_to_bottom()

    def _scroll_to_bottom(self):
        self.chat_view.moveCursor(QTextCursor.MoveOperation.End)

    @staticmethod
    def _escape(text: str) -> str:
        return (
            text.replace("&", "&amp;")
            .replace("<", "&lt;")
            .replace(">", "&gt;")
        )

def main():
    app = QApplication(sys.argv)
    window = ChatWindow()
    window.show()
    sys.exit(app.exec())

if __name__ == "__main__":
    main()

PDF_GLOB_PATTERN = "./assets/docs/kopodoc/*.pdf"
EMBEDDING_MODEL = "text-embedding-3-large"
LLM_MODEL = "exaone3.5:7.8b"
CHROMA_COLLECTION_NAME = "openai"
PROMPT_TEMPLATE = """..."""
WELCOME_TEXT = "..."

class IndexingWorker(QThread):
    progress = pyqtSignal(str)
    finished_ok = pyqtSignal(object)
    failed = pyqtSignal(str)

    def run(self):
        ...

class QueryWorker(QThread):
    finished_ok = pyqtSignal(str)
    failed = pyqtSignal(str)

    def __init__(self, chain, question: str):
        ...
    def run(self):
        answer = self.chain.invoke(self.question)
        self.finished_ok.emit(answer)

def _start_indexing(self):
    self.indexing_worker = IndexingWorker()
    self.indexing_worker.progress.connect(self._on_indexing_progress)
    self.indexing_worker.finished_ok.connect(self._on_indexing_finished)
    self.indexing_worker.failed.connect(self._on_indexing_failed)
    self.indexing_worker.start()

def _on_send(self):
    question = self.input_line.text().strip()
    if not question or self.chain is None:
        return
    self._append_user_message(question)
    self.input_line.clear()
    self.input_line.setEnabled(False)
    self.send_button.setEnabled(False)
    ...
    self.query_worker = QueryWorker(self.chain, question)
    self.query_worker.finished_ok.connect(self._on_answer_ready)
    self.query_worker.failed.connect(self._on_answer_failed)
    self.query_worker.start()

def _append_ai_message(self, text: str):
    html_body = self._markdown_to_html(text)
    self.chat_view.append(f"<div style='color:#0b8043;'><b>AI ▶</b></div>{html_body}")