from fastapi import FastAPI, BackgroundTasks, UploadFile, File, Form, Request, Query
from fastapi.responses import HTMLResponse, JSONResponse, Response, RedirectResponse
from fastapi.staticfiles import StaticFiles
import pathlib, os, uvicorn, base64, json, shutil, uuid, time, urllib.parse
from typing import Dict, List, Any, Optional
import asyncio
import logging
import threading
import concurrent.futures
from openai import OpenAI
import fitz  # PyMuPDF
import tempfile
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet
import io
import docx2txt

# 로깅 설정
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

BASE = pathlib.Path(__file__).parent
app = FastAPI()
app.mount("/static", StaticFiles(directory=BASE), name="static")

# PDF 디렉토리 설정
PDF_DIR = BASE / "pdf"
if not PDF_DIR.exists():
    PDF_DIR.mkdir(parents=True)

# 영구 PDF 디렉토리 설정 (Hugging Face 영구 디스크)
PERMANENT_PDF_DIR = pathlib.Path("/data/pdfs") if os.path.exists("/data") else BASE / "permanent_pdfs"
if not PERMANENT_PDF_DIR.exists():
    PERMANENT_PDF_DIR.mkdir(parents=True)

# 캐시 디렉토리 설정
CACHE_DIR = BASE / "cache"
if not CACHE_DIR.exists():
    CACHE_DIR.mkdir(parents=True)

# PDF 메타데이터 디렉토리 및 파일 설정
METADATA_DIR = pathlib.Path("/data/metadata") if os.path.exists("/data") else BASE / "metadata"
if not METADATA_DIR.exists():
    METADATA_DIR.mkdir(parents=True)
PDF_METADATA_FILE = METADATA_DIR / "pdf_metadata.json"

# 임베딩 캐시 디렉토리 설정
EMBEDDING_DIR = pathlib.Path("/data/embeddings") if os.path.exists("/data") else BASE / "embeddings"
if not EMBEDDING_DIR.exists():
    EMBEDDING_DIR.mkdir(parents=True)

# 관리자 비밀번호
ADMIN_PASSWORD = os.getenv("PASSWORD", "admin")  # 환경 변수에서 가져오기, 기본값은 테스트용

# OpenAI API 키 설정
OPENAI_API_KEY = os.getenv("LLM_API", "")
# API 키가 없거나 비어있을 때 플래그 설정
HAS_VALID_API_KEY = bool(OPENAI_API_KEY and OPENAI_API_KEY.strip())

if HAS_VALID_API_KEY:
    try:
        openai_client = OpenAI(api_key=OPENAI_API_KEY, timeout=30.0)
        logger.info("OpenAI 클라이언트 초기화 성공")
    except Exception as e:
        logger.error(f"OpenAI 클라이언트 초기화 실패: {e}")
        HAS_VALID_API_KEY = False
else:
    logger.warning("유효한 OpenAI API 키가 없습니다. AI 기능이 제한됩니다.")
    openai_client = None

# 전역 캐시 객체
pdf_cache: Dict[str, Dict[str, Any]] = {}
# 캐싱 락
cache_locks = {}
# PDF 메타데이터 (ID to 경로 매핑)
pdf_metadata: Dict[str, str] = {}
# PDF 임베딩 캐시
pdf_embeddings: Dict[str, Dict[str, Any]] = {}

# PDF 메타데이터 로드
def load_pdf_metadata():
    global pdf_metadata
    if PDF_METADATA_FILE.exists():
        try:
            with open(PDF_METADATA_FILE, "r") as f:
                pdf_metadata = json.load(f)
            logger.info(f"PDF 메타데이터 로드 완료: {len(pdf_metadata)} 항목")
        except Exception as e:
            logger.error(f"메타데이터 로드 오류: {e}")
            pdf_metadata = {}
    else:
        pdf_metadata = {}

# PDF 메타데이터 저장
def save_pdf_metadata():
    try:
        with open(PDF_METADATA_FILE, "w") as f:
            json.dump(pdf_metadata, f)
    except Exception as e:
        logger.error(f"메타데이터 저장 오류: {e}")

# PDF ID 생성 (파일명 + 타임스탬프 기반) - 더 단순하고 안전한 방식으로 변경
def generate_pdf_id(filename: str) -> str:
    # 파일명에서 확장자 제거
    base_name = os.path.splitext(filename)[0]
    # 안전한 문자열로 변환 (URL 인코딩 대신 직접 변환)
    import re
    safe_name = re.sub(r'[^\w\-_]', '_', base_name.replace(" ", "_"))
    # 타임스탬프 추가로 고유성 보장
    timestamp = int(time.time())
    # 짧은 임의 문자열 추가
    random_suffix = uuid.uuid4().hex[:6]
    return f"{safe_name}_{timestamp}_{random_suffix}"

# PDF 파일 목록 가져오기 (메인 디렉토리용)
def get_pdf_files():
    pdf_files = []
    if PDF_DIR.exists():
        pdf_files = [f for f in PDF_DIR.glob("*.pdf")]
    return pdf_files

# 영구 저장소의 PDF 파일 목록 가져오기
def get_permanent_pdf_files():
    pdf_files = []
    if PERMANENT_PDF_DIR.exists():
        pdf_files = [f for f in PERMANENT_PDF_DIR.glob("*.pdf")]
    return pdf_files

# PDF 썸네일 생성 및 프로젝트 데이터 준비
def generate_pdf_projects():
    projects_data = []
    
    # 메인 디렉토리와 영구 저장소의 파일들 가져오기
    pdf_files = get_pdf_files()
    permanent_pdf_files = get_permanent_pdf_files()
    
    # 모든 파일 합치기 (파일명 기준으로 중복 제거)
    unique_files = {}
    
    # 먼저 메인 디렉토리의 파일들 추가
    for file in pdf_files:
        unique_files[file.name] = file
    
    # 영구 저장소의 파일들 추가 (동일 파일명이 있으면 영구 저장소 파일 우선)
    for file in permanent_pdf_files:
        unique_files[file.name] = file
    
    # 중복 제거된 파일들로 프로젝트 데이터 생성
    for pdf_file in unique_files.values():
        # 해당 파일의 PDF ID 찾기
        pdf_id = None
        for pid, path in pdf_metadata.items():
            if os.path.basename(path) == pdf_file.name:
                pdf_id = pid
                break
        
        # ID가 없으면 새로 생성하고 메타데이터에 추가
        if not pdf_id:
            pdf_id = generate_pdf_id(pdf_file.name)
            pdf_metadata[pdf_id] = str(pdf_file)
            save_pdf_metadata()
        
        projects_data.append({
            "path": str(pdf_file),
            "name": pdf_file.stem,
            "id": pdf_id,
            "cached": pdf_file.stem in pdf_cache and pdf_cache[pdf_file.stem].get("status") == "completed"
        })
    
    return projects_data

# 캐시 파일 경로 생성
def get_cache_path(pdf_name: str):
    return CACHE_DIR / f"{pdf_name}_cache.json"

# 임베딩 캐시 파일 경로 생성
def get_embedding_path(pdf_id: str):
    return EMBEDDING_DIR / f"{pdf_id}_embedding.json"

# PDF 텍스트 추출 함수
def extract_pdf_text(pdf_path: str) -> List[Dict[str, Any]]:
    try:
        doc = fitz.open(pdf_path)
        chunks = []
        
        for page_num in range(len(doc)):
            page = doc[page_num]
            text = page.get_text()
            
            # 페이지 텍스트가 있는 경우만 추가
            if text.strip():
                chunks.append({
                    "page": page_num + 1,
                    "text": text,
                    "chunk_id": f"page_{page_num + 1}"
                })
        
        return chunks
    except Exception as e:
        logger.error(f"PDF 텍스트 추출 오류: {e}")
        return []

# PDF ID로 임베딩 생성 또는 가져오기
async def get_pdf_embedding(pdf_id: str) -> Dict[str, Any]:
    try:
        # 임베딩 캐시 확인
        embedding_path = get_embedding_path(pdf_id)
        if embedding_path.exists():
            try:
                with open(embedding_path, "r", encoding="utf-8") as f:
                    return json.load(f)
            except Exception as e:
                logger.error(f"임베딩 캐시 로드 오류: {e}")
        
        # PDF 경로 찾기
        pdf_path = get_pdf_path_by_id(pdf_id)
        if not pdf_path:
            raise ValueError(f"PDF ID {pdf_id}에 해당하는 파일을 찾을 수 없습니다")
        
        # 텍스트 추출
        chunks = extract_pdf_text(pdf_path)
        if not chunks:
            raise ValueError(f"PDF에서 텍스트를 추출할 수 없습니다: {pdf_path}")
        
        # 임베딩 저장 및 반환
        embedding_data = {
            "pdf_id": pdf_id,
            "pdf_path": pdf_path,
            "chunks": chunks,
            "created_at": time.time()
        }
        
        # 임베딩 캐시 저장
        with open(embedding_path, "w", encoding="utf-8") as f:
            json.dump(embedding_data, f, ensure_ascii=False)
        
        return embedding_data
    
    except Exception as e:
        logger.error(f"PDF 임베딩 생성 오류: {e}")
        return {"error": str(e), "pdf_id": pdf_id}

# PDF 내용 기반 질의응답
# PDF 내용 기반 질의응답 함수 개선
async def query_pdf(pdf_id: str, query: str) -> Dict[str, Any]:
    try:
        # API 키가 없거나 유효하지 않은 경우
        if not HAS_VALID_API_KEY or not openai_client:
            return {
                "error": "OpenAI API 키가 설정되지 않았습니다.",
                "answer": "죄송합니다. 현재 AI 기능이 비활성화되어 있어 질문에 답변할 수 없습니다. 시스템 관리자에게 문의하세요."
            }
        
        # 임베딩 데이터 가져오기
        embedding_data = await get_pdf_embedding(pdf_id)
        if "error" in embedding_data:
            return {"error": embedding_data["error"]}
        
        # 청크 텍스트 모으기 (임시로 간단하게 전체 텍스트 사용)
        all_text = "\n\n".join([f"Page {chunk['page']}: {chunk['text']}" for chunk in embedding_data["chunks"]])
        
        # 컨텍스트 크기를 고려하여 텍스트가 너무 길면 앞부분만 사용
        max_context_length = 60000  # 토큰 수가 아닌 문자 수 기준 (대략적인 제한)
        if len(all_text) > max_context_length:
            all_text = all_text[:max_context_length] + "...(이하 생략)"
        
        # 시스템 프롬프트 준비
        system_prompt = """
        당신은 PDF 내용을 기반으로 질문에 답변하는 도우미입니다. 제공된 PDF 컨텍스트 정보만을 사용하여 답변하세요.
        컨텍스트에 관련 정보가 없는 경우, '제공된 PDF에서 해당 정보를 찾을 수 없습니다'라고 솔직히 답하세요.
        답변은 명확하고 간결하게 작성하고, 관련 페이지 번호를 인용하세요. 반드시 공손한 말투로 친절하게 응답하세요. 
        """
        
        # gpt-4.1-mini 모델 사용
        try:
            # 타임아웃 및 재시도 설정 개선
            for attempt in range(3):  # 최대 3번 재시도
                try:
                    response = openai_client.chat.completions.create(
                        model="gpt-4.1-mini",
                        messages=[
                            {"role": "system", "content": system_prompt},
                            {"role": "user", "content": f"다음 PDF 내용을 참고하여 질문에 답변해주세요.\n\nPDF 내용:\n{all_text}\n\n질문: {query}"}
                        ],
                        temperature=0.7,
                        max_tokens=2048,
                        timeout=30.0  # 30초 타임아웃
                    )
                    
                    answer = response.choices[0].message.content
                    return {
                        "answer": answer,
                        "pdf_id": pdf_id,
                        "query": query
                    }
                except Exception as api_error:
                    logger.error(f"OpenAI API 호출 오류 (시도 {attempt+1}/3): {api_error}")
                    if attempt == 2:  # 마지막 시도에서도 실패
                        raise api_error
                    await asyncio.sleep(1 * (attempt + 1))  # 재시도 간 지연 시간 증가
            
            # 여기까지 도달하지 않아야 함
            raise Exception("API 호출 재시도 모두 실패")
        except Exception as api_error:
            logger.error(f"OpenAI API 호출 최종 오류: {api_error}")
            # 오류 유형에 따른 더 명확한 메시지 제공
            error_message = str(api_error)
            if "Connection" in error_message:
                return {"error": "OpenAI 서버와 연결할 수 없습니다. 인터넷 연결을 확인하세요."}
            elif "Unauthorized" in error_message or "Authentication" in error_message:
                return {"error": "API 키가 유효하지 않습니다."}
            elif "Rate limit" in error_message:
                return {"error": "API 호출 한도를 초과했습니다. 잠시 후 다시 시도하세요."}
            else:
                return {"error": f"AI 응답 생성 중 오류가 발생했습니다: {error_message}"}
        
    except Exception as e:
        logger.error(f"질의응답 처리 오류: {e}")
        return {"error": str(e)}

# PDF 요약 생성
# PDF 요약 생성 함수 개선
async def summarize_pdf(pdf_id: str) -> Dict[str, Any]:
    try:
        # API 키가 없거나 유효하지 않은 경우
        if not HAS_VALID_API_KEY or not openai_client:
            return {
                "error": "OpenAI API 키가 설정되지 않았습니다. 'LLM_API' 환경 변수를 확인하세요.",
                "summary": "API 키가 없어 요약을 생성할 수 없습니다. 시스템 관리자에게 문의하세요."
            }
        
        # 임베딩 데이터 가져오기
        embedding_data = await get_pdf_embedding(pdf_id)
        if "error" in embedding_data:
            return {"error": embedding_data["error"], "summary": "PDF에서 텍스트를 추출할 수 없습니다."}
        
        # 청크 텍스트 모으기 (제한된 길이)
        all_text = "\n\n".join([f"Page {chunk['page']}: {chunk['text']}" for chunk in embedding_data["chunks"]])
        
        # 컨텍스트 크기를 고려하여 텍스트가 너무 길면 앞부분만 사용
        max_context_length = 60000  # 토큰 수가 아닌 문자 수 기준 (대략적인 제한)
        if len(all_text) > max_context_length:
            all_text = all_text[:max_context_length] + "...(이하 생략)"
        
        # OpenAI API 호출
        try:
            # 타임아웃 및 재시도 설정 개선
            for attempt in range(3):  # 최대 3번 재시도
                try:
                    response = openai_client.chat.completions.create(
                        model="gpt-4.1-mini",
                        messages=[
                            {"role": "system", "content": "다음 PDF 내용을 간결하게 요약해주세요. 핵심 주제와 주요 포인트를 포함한 요약을 500자 이내로 작성해주세요."},
                            {"role": "user", "content": f"PDF 내용:\n{all_text}"}
                        ],
                        temperature=0.7,
                        max_tokens=1024,
                        timeout=30.0  # 30초 타임아웃
                    )
                    
                    summary = response.choices[0].message.content
                    return {
                        "summary": summary,
                        "pdf_id": pdf_id
                    }
                except Exception as api_error:
                    logger.error(f"OpenAI API 호출 오류 (시도 {attempt+1}/3): {api_error}")
                    if attempt == 2:  # 마지막 시도에서도 실패
                        raise api_error
                    await asyncio.sleep(1 * (attempt + 1))  # 재시도 간 지연 시간 증가
            
            # 여기까지 도달하지 않아야 함
            raise Exception("API 호출 재시도 모두 실패")
        except Exception as api_error:
            logger.error(f"OpenAI API 호출 최종 오류: {api_error}")
            # 오류 유형에 따른 더 명확한 메시지 제공
            error_message = str(api_error)
            if "Connection" in error_message:
                return {"error": "OpenAI 서버와 연결할 수 없습니다. 인터넷 연결을 확인하세요.", "pdf_id": pdf_id}
            elif "Unauthorized" in error_message or "Authentication" in error_message:
                return {"error": "API 키가 유효하지 않습니다.", "pdf_id": pdf_id}
            elif "Rate limit" in error_message:
                return {"error": "API 호출 한도를 초과했습니다. 잠시 후 다시 시도하세요.", "pdf_id": pdf_id}
            else:
                return {"error": f"AI 요약 생성 중 오류가 발생했습니다: {error_message}", "pdf_id": pdf_id}
    
    except Exception as e:
        logger.error(f"PDF 요약 생성 오류: {e}")
        return {
            "error": str(e),
            "summary": "PDF 요약 중 오류가 발생했습니다. PDF 페이지 수가 너무 많거나 형식이 지원되지 않을 수 있습니다."
        }

        
# 최적화된 PDF 페이지 캐싱 함수
async def cache_pdf(pdf_path: str):
    try:
        import fitz  # PyMuPDF
        
        pdf_file = pathlib.Path(pdf_path)
        pdf_name = pdf_file.stem
        
        # 락 생성 - 동일한 PDF에 대해 동시 캐싱 방지
        if pdf_name not in cache_locks:
            cache_locks[pdf_name] = threading.Lock()
        
        # 이미 캐싱 중이거나 캐싱 완료된 PDF는 건너뛰기
        if pdf_name in pdf_cache and pdf_cache[pdf_name].get("status") in ["processing", "completed"]:
            logger.info(f"PDF {pdf_name} 이미 캐싱 완료 또는 진행 중")
            return
        
        with cache_locks[pdf_name]:
            # 이중 체크 - 락 획득 후 다시 확인
            if pdf_name in pdf_cache and pdf_cache[pdf_name].get("status") in ["processing", "completed"]:
                return
            
            # 캐시 상태 업데이트
            pdf_cache[pdf_name] = {"status": "processing", "progress": 0, "pages": []}
            
            # 캐시 파일이 이미 존재하는지 확인
            cache_path = get_cache_path(pdf_name)
            if cache_path.exists():
                try:
                    with open(cache_path, "r") as cache_file:
                        cached_data = json.load(cache_file)
                        if cached_data.get("status") == "completed" and cached_data.get("pages"):
                            pdf_cache[pdf_name] = cached_data
                            pdf_cache[pdf_name]["status"] = "completed"
                            logger.info(f"캐시 파일에서 {pdf_name} 로드 완료")
                            return
                except Exception as e:
                    logger.error(f"캐시 파일 로드 실패: {e}")
            
            # PDF 파일 열기
            doc = fitz.open(pdf_path)
            total_pages = doc.page_count
            
            # 미리 썸네일만 먼저 생성 (빠른 UI 로딩용)
            if total_pages > 0:
                # 첫 페이지 썸네일 생성
                page = doc[0]
                pix_thumb = page.get_pixmap(matrix=fitz.Matrix(0.2, 0.2))  # 더 작은 썸네일
                thumb_data = pix_thumb.tobytes("png")
                b64_thumb = base64.b64encode(thumb_data).decode('utf-8')
                thumb_src = f"data:image/png;base64,{b64_thumb}"
                
                # 썸네일 페이지만 먼저 캐시
                pdf_cache[pdf_name]["pages"] = [{"thumb": thumb_src, "src": ""}]
                pdf_cache[pdf_name]["progress"] = 1
                pdf_cache[pdf_name]["total_pages"] = total_pages
            
            # 이미지 해상도 및 압축 품질 설정 (성능 최적화)
            scale_factor = 1.0  # 기본 해상도 (낮출수록 로딩 빠름)
            jpeg_quality = 80   # JPEG 품질 (낮출수록 용량 작아짐)
            
            # 페이지 처리 작업자 함수 (병렬 처리용)
            def process_page(page_num):
                try:
                    page = doc[page_num]
                    
                    # 이미지로 변환 시 매트릭스 스케일링 적용 (성능 최적화)
                    pix = page.get_pixmap(matrix=fitz.Matrix(scale_factor, scale_factor))
                    
                    # JPEG 형식으로 인코딩 (PNG보다 크기 작음)
                    img_data = pix.tobytes("jpeg", jpeg_quality)
                    b64_img = base64.b64encode(img_data).decode('utf-8')
                    img_src = f"data:image/jpeg;base64,{b64_img}"
                    
                    # 썸네일 (첫 페이지가 아니면 빈 문자열)
                    thumb_src = "" if page_num > 0 else pdf_cache[pdf_name]["pages"][0]["thumb"]
                    
                    return {
                        "page_num": page_num,
                        "src": img_src,
                        "thumb": thumb_src
                    }
                except Exception as e:
                    logger.error(f"페이지 {page_num} 처리 오류: {e}")
                    return {
                        "page_num": page_num,
                        "src": "",
                        "thumb": "",
                        "error": str(e)
                    }
            
            # 병렬 처리로 모든 페이지 처리
            pages = [None] * total_pages
            processed_count = 0
            
            # 페이지 배치 처리 (메모리 관리)
            batch_size = 5  # 한 번에 처리할 페이지 수
            
            for batch_start in range(0, total_pages, batch_size):
                batch_end = min(batch_start + batch_size, total_pages)
                current_batch = list(range(batch_start, batch_end))
                
                # 병렬 처리로 배치 페이지 렌더링
                with concurrent.futures.ThreadPoolExecutor(max_workers=min(5, batch_size)) as executor:
                    batch_results = list(executor.map(process_page, current_batch))
                
                # 결과 저장
                for result in batch_results:
                    page_num = result["page_num"]
                    pages[page_num] = {
                        "src": result["src"],
                        "thumb": result["thumb"]
                    }
                    
                    processed_count += 1
                    progress = round(processed_count / total_pages * 100)
                    pdf_cache[pdf_name]["progress"] = progress
                
                # 중간 저장
                pdf_cache[pdf_name]["pages"] = pages
                try:
                    with open(cache_path, "w") as cache_file:
                        json.dump({
                            "status": "processing", 
                            "progress": pdf_cache[pdf_name]["progress"], 
                            "pages": pdf_cache[pdf_name]["pages"],
                            "total_pages": total_pages
                        }, cache_file)
                except Exception as e:
                    logger.error(f"중간 캐시 저장 실패: {e}")
            
            # 캐싱 완료
            pdf_cache[pdf_name] = {
                "status": "completed",
                "progress": 100,
                "pages": pages,
                "total_pages": total_pages
            }
            
            # 최종 캐시 파일 저장
            try:
                with open(cache_path, "w") as cache_file:
                    json.dump(pdf_cache[pdf_name], cache_file)
                logger.info(f"PDF {pdf_name} 캐싱 완료, {total_pages}페이지")
            except Exception as e:
                logger.error(f"최종 캐시 저장 실패: {e}")
            
    except Exception as e:
        import traceback
        logger.error(f"PDF 캐싱 오류: {str(e)}\n{traceback.format_exc()}")
        if pdf_name in pdf_cache:
            pdf_cache[pdf_name]["status"] = "error"
            pdf_cache[pdf_name]["error"] = str(e)

# PDF ID로 PDF 경로 찾기 (개선된 검색 로직)
def get_pdf_path_by_id(pdf_id: str) -> str:
    logger.info(f"PDF ID로 파일 조회: {pdf_id}")
    
    # 1. 메타데이터에서 직접 ID로 검색
    if pdf_id in pdf_metadata:
        path = pdf_metadata[pdf_id]
        # 파일 존재 확인
        if os.path.exists(path):
            return path
        
        # 파일이 이동했을 수 있으므로 파일명으로 검색
        filename = os.path.basename(path)
        
        # 영구 저장소에서 검색
        perm_path = PERMANENT_PDF_DIR / filename
        if perm_path.exists():
            # 메타데이터 업데이트
            pdf_metadata[pdf_id] = str(perm_path)
            save_pdf_metadata()
            return str(perm_path)
            
        # 메인 디렉토리에서 검색
        main_path = PDF_DIR / filename
        if main_path.exists():
            # 메타데이터 업데이트
            pdf_metadata[pdf_id] = str(main_path)
            save_pdf_metadata()
            return str(main_path)
    
    # 2. 파일명 부분만 추출하여 모든 PDF 파일 검색
    try:
        # ID 형식: filename_timestamp_random
        # 파일명 부분만 추출
        name_part = pdf_id.split('_')[0] if '_' in pdf_id else pdf_id
        
        # 모든 PDF 파일 검색
        for file_path in get_pdf_files() + get_permanent_pdf_files():
            # 파일명이 ID의 시작 부분과 일치하면
            file_basename = os.path.basename(file_path)
            if file_basename.startswith(name_part) or file_path.stem.startswith(name_part):
                # ID 매핑 업데이트
                pdf_metadata[pdf_id] = str(file_path)
                save_pdf_metadata()
                return str(file_path)
    except Exception as e:
        logger.error(f"파일명 검색 중 오류: {e}")
    
    # 3. 모든 PDF 파일에 대해 메타데이터 확인
    for pid, path in pdf_metadata.items():
        if os.path.exists(path):
            file_basename = os.path.basename(path)
            # 유사한 파일명을 가진 경우
            if pdf_id in pid or pid in pdf_id:
                pdf_metadata[pdf_id] = path
                save_pdf_metadata()
                return path
    
    return None

# 시작 시 모든 PDF 파일 캐싱
async def init_cache_all_pdfs():
    logger.info("PDF 캐싱 작업 시작")
    
    # PDF 메타데이터 로드
    load_pdf_metadata()
    
    # 메인 및 영구 디렉토리에서 PDF 파일 모두 가져오기
    pdf_files = get_pdf_files() + get_permanent_pdf_files()
    
    # 중복 제거
    unique_pdf_paths = set(str(p) for p in pdf_files)
    pdf_files = [pathlib.Path(p) for p in unique_pdf_paths]
    
    # 파일 기반 메타데이터 업데이트
    for pdf_file in pdf_files:
        # ID가 없는 파일에 대해 ID 생성
        found = False
        for pid, path in pdf_metadata.items():
            if os.path.basename(path) == pdf_file.name:
                found = True
                # 경로 업데이트 필요한 경우
                if not os.path.exists(path):
                    pdf_metadata[pid] = str(pdf_file)
                break
        
        if not found:
            pdf_id = generate_pdf_id(pdf_file.name)
            pdf_metadata[pdf_id] = str(pdf_file)
    
    # 메타데이터 저장
    save_pdf_metadata()
    
    # 이미 캐시된 PDF 파일 로드 (빠른 시작을 위해 먼저 수행)
    for cache_file in CACHE_DIR.glob("*_cache.json"):
        try:
            pdf_name = cache_file.stem.replace("_cache", "")
            with open(cache_file, "r") as f:
                cached_data = json.load(f)
                if cached_data.get("status") == "completed" and cached_data.get("pages"):
                    pdf_cache[pdf_name] = cached_data
                    pdf_cache[pdf_name]["status"] = "completed"
                    logger.info(f"기존 캐시 로드: {pdf_name}")
        except Exception as e:
            logger.error(f"캐시 파일 로드 오류: {str(e)}")
    
    # 캐싱되지 않은 PDF 파일 병렬 처리
    await asyncio.gather(*[asyncio.create_task(cache_pdf(str(pdf_file))) 
                          for pdf_file in pdf_files 
                          if pdf_file.stem not in pdf_cache 
                          or pdf_cache[pdf_file.stem].get("status") != "completed"])

# 백그라운드 작업 시작 함수
@app.on_event("startup")
async def startup_event():
    # PDF 메타데이터 로드
    load_pdf_metadata()
    
    # 누락된 PDF 파일에 대한 메타데이터 생성
    for pdf_file in get_pdf_files() + get_permanent_pdf_files():
        found = False
        for pid, path in pdf_metadata.items():
            if os.path.basename(path) == pdf_file.name:
                found = True
                # 경로 업데이트
                if not os.path.exists(path):
                    pdf_metadata[pid] = str(pdf_file)
                break
        
        if not found:
            # 새 ID 생성 및 메타데이터에 추가
            pdf_id = generate_pdf_id(pdf_file.name)
            pdf_metadata[pdf_id] = str(pdf_file)
    
    # 변경사항 저장
    save_pdf_metadata()
    
    # 백그라운드 태스크로 캐싱 실행
    asyncio.create_task(init_cache_all_pdfs())

# API 엔드포인트: PDF 프로젝트 목록
@app.get("/api/pdf-projects")
async def get_pdf_projects_api():
    return generate_pdf_projects()

# API 엔드포인트: 영구 저장된 PDF 프로젝트 목록
@app.get("/api/permanent-pdf-projects")
async def get_permanent_pdf_projects_api():
    pdf_files = get_permanent_pdf_files()
    projects_data = []
    
    for pdf_file in pdf_files:
        # PDF ID 찾기
        pdf_id = None
        for pid, path in pdf_metadata.items():
            if os.path.basename(path) == pdf_file.name:
                pdf_id = pid
                break
        
        # ID가 없으면 생성
        if not pdf_id:
            pdf_id = generate_pdf_id(pdf_file.name)
            pdf_metadata[pdf_id] = str(pdf_file)
            save_pdf_metadata()
            
        projects_data.append({
            "path": str(pdf_file),
            "name": pdf_file.stem,
            "id": pdf_id,
            "cached": pdf_file.stem in pdf_cache and pdf_cache[pdf_file.stem].get("status") == "completed"
        })
    
    return projects_data

# API 엔드포인트: PDF ID로 정보 가져오기
@app.get("/api/pdf-info-by-id/{pdf_id}")
async def get_pdf_info_by_id(pdf_id: str):
    pdf_path = get_pdf_path_by_id(pdf_id)
    if pdf_path:
        pdf_file = pathlib.Path(pdf_path)
        return {
            "path": pdf_path,
            "name": pdf_file.stem,
            "id": pdf_id,
            "exists": True,
            "cached": pdf_file.stem in pdf_cache and pdf_cache[pdf_file.stem].get("status") == "completed"
        }
    return {"exists": False, "error": "PDF를 찾을 수 없습니다"}

# API 엔드포인트: PDF 썸네일 제공 (최적화)
@app.get("/api/pdf-thumbnail")
async def get_pdf_thumbnail(path: str):
    try:
        pdf_file = pathlib.Path(path)
        pdf_name = pdf_file.stem
        
        # 캐시에서 썸네일 가져오기
        if pdf_name in pdf_cache and pdf_cache[pdf_name].get("pages"):
            if pdf_cache[pdf_name]["pages"][0].get("thumb"):
                return {"thumbnail": pdf_cache[pdf_name]["pages"][0]["thumb"]}
            
        # 캐시에 없으면 생성 (더 작고 빠른 썸네일)
        import fitz
        doc = fitz.open(path)
        if doc.page_count > 0:
            page = doc[0]
            pix = page.get_pixmap(matrix=fitz.Matrix(0.2, 0.2))  # 더 작은 썸네일
            img_data = pix.tobytes("jpeg", 70)  # JPEG 압축 사용
            b64_img = base64.b64encode(img_data).decode('utf-8')
            
            # 백그라운드에서 캐싱 시작
            asyncio.create_task(cache_pdf(path))
            
            return {"thumbnail": f"data:image/jpeg;base64,{b64_img}"}
        
        return {"thumbnail": None}
    except Exception as e:
        logger.error(f"썸네일 생성 오류: {str(e)}")
        return {"error": str(e), "thumbnail": None}

# API 엔드포인트: 캐시 상태 확인
@app.get("/api/cache-status")
async def get_cache_status(path: str = None):
    if path:
        pdf_file = pathlib.Path(path)
        pdf_name = pdf_file.stem
        if pdf_name in pdf_cache:
            return pdf_cache[pdf_name]
        return {"status": "not_cached"}
    else:
        return {name: {"status": info["status"], "progress": info.get("progress", 0)} 
                for name, info in pdf_cache.items()}

# API 엔드포인트: PDF에 대한 질의응답
@app.post("/api/ai/query-pdf/{pdf_id}")
async def api_query_pdf(pdf_id: str, query: Dict[str, str]):
    try:
        user_query = query.get("query", "")
        if not user_query:
            return JSONResponse(content={"error": "질문이 제공되지 않았습니다"}, status_code=400)
        
        # PDF 경로 확인
        pdf_path = get_pdf_path_by_id(pdf_id)
        if not pdf_path:
            return JSONResponse(content={"error": f"PDF ID {pdf_id}에 해당하는 파일을 찾을 수 없습니다"}, status_code=404)
        
        # 질의응답 처리
        result = await query_pdf(pdf_id, user_query)
        
        if "error" in result:
            return JSONResponse(content={"error": result["error"]}, status_code=500)
        
        return result
    except Exception as e:
        logger.error(f"질의응답 API 오류: {e}")
        return JSONResponse(content={"error": str(e)}, status_code=500)

# API 엔드포인트: PDF 요약
@app.get("/api/ai/summarize-pdf/{pdf_id}")
async def api_summarize_pdf(pdf_id: str):
    try:
        # PDF 경로 확인
        pdf_path = get_pdf_path_by_id(pdf_id)
        if not pdf_path:
            return JSONResponse(content={"error": f"PDF ID {pdf_id}에 해당하는 파일을 찾을 수 없습니다"}, status_code=404)
        
        # 요약 처리
        result = await summarize_pdf(pdf_id)
        
        if "error" in result:
            return JSONResponse(content={"error": result["error"]}, status_code=500)
        
        return result
    except Exception as e:
        logger.error(f"PDF 요약 API 오류: {e}")
        return JSONResponse(content={"error": str(e)}, status_code=500)

# API 엔드포인트: 캐시된 PDF 콘텐츠 제공 (점진적 로딩 지원)
@app.get("/api/cached-pdf")
async def get_cached_pdf(path: str, background_tasks: BackgroundTasks):
    try:
        pdf_file = pathlib.Path(path)
        pdf_name = pdf_file.stem
        
        # 캐시 확인
        if pdf_name in pdf_cache:
            status = pdf_cache[pdf_name].get("status", "")
            
            # 완료된 경우 전체 데이터 반환
            if status == "completed":
                return pdf_cache[pdf_name]
            
            # 처리 중인 경우 현재까지의 페이지 데이터 포함 (점진적 로딩)
            elif status == "processing":
                progress = pdf_cache[pdf_name].get("progress", 0)
                pages = pdf_cache[pdf_name].get("pages", [])
                total_pages = pdf_cache[pdf_name].get("total_pages", 0)
                
                # 일부만 처리된 경우에도 사용 가능한 페이지 제공
                return {
                    "status": "processing", 
                    "progress": progress,
                    "pages": pages,
                    "total_pages": total_pages,
                    "available_pages": len([p for p in pages if p and p.get("src")])
                }
        
        # 캐시가 없는 경우 백그라운드에서 캐싱 시작
        background_tasks.add_task(cache_pdf, path)
        return {"status": "started", "progress": 0}
        
    except Exception as e:
        logger.error(f"캐시된 PDF 제공 오류: {str(e)}")
        return {"error": str(e), "status": "error"}

# API 엔드포인트: PDF 원본 콘텐츠 제공(캐시가 없는 경우)
@app.get("/api/pdf-content")
async def get_pdf_content(path: str, background_tasks: BackgroundTasks):
    try:
        # 캐싱 상태 확인
        pdf_file = pathlib.Path(path)
        if not pdf_file.exists():
            return JSONResponse(content={"error": f"파일을 찾을 수 없습니다: {path}"}, status_code=404)
        
        pdf_name = pdf_file.stem
        
        # 캐시된 경우 리다이렉트
        if pdf_name in pdf_cache and (pdf_cache[pdf_name].get("status") == "completed" 
                                     or (pdf_cache[pdf_name].get("status") == "processing" 
                                         and pdf_cache[pdf_name].get("progress", 0) > 10)):
            return JSONResponse(content={"redirect": f"/api/cached-pdf?path={path}"})
        
        # 파일 읽기
        with open(path, "rb") as pdf_file:
            content = pdf_file.read()
            
        # 파일명 처리
        import urllib.parse
        filename = pdf_file.name
        encoded_filename = urllib.parse.quote(filename)
        
        # 백그라운드에서 캐싱 시작
        background_tasks.add_task(cache_pdf, path)
        
        # 응답 헤더 설정
        headers = {
            "Content-Type": "application/pdf",
            "Content-Disposition": f"inline; filename=\"{encoded_filename}\"; filename*=UTF-8''{encoded_filename}"
        }
        
        return Response(content=content, media_type="application/pdf", headers=headers)
    except Exception as e:
        import traceback
        error_details = traceback.format_exc()
        logger.error(f"PDF 콘텐츠 로드 오류: {str(e)}\n{error_details}")
        return JSONResponse(content={"error": str(e)}, status_code=500)

# PDF 업로드 엔드포인트 - 영구 저장소에 저장 및 메인 화면에 자동 표시
@app.post("/api/upload-pdf")
async def upload_pdf(file: UploadFile = File(...)):
    try:
        # 파일 이름 확인
        if not file.filename.lower().endswith('.pdf'):
            return JSONResponse(
                content={"success": False, "message": "PDF 파일만 업로드 가능합니다"}, 
                status_code=400
            )
        
        # 영구 저장소에 파일 저장
        file_path = PERMANENT_PDF_DIR / file.filename
        
        # 파일 읽기 및 저장
        content = await file.read()
        with open(file_path, "wb") as buffer:
            buffer.write(content)
        
        # 메인 디렉토리에도 자동으로 복사 (자동 표시)
        with open(PDF_DIR / file.filename, "wb") as buffer:
            buffer.write(content)
        
        # PDF ID 생성 및 메타데이터 저장
        pdf_id = generate_pdf_id(file.filename)
        pdf_metadata[pdf_id] = str(file_path)
        save_pdf_metadata()
        
        # 백그라운드에서 캐싱 시작
        asyncio.create_task(cache_pdf(str(file_path)))
        
        return JSONResponse(
            content={
                "success": True, 
                "path": str(file_path), 
                "name": file_path.stem,
                "id": pdf_id,
                "viewUrl": f"/view/{pdf_id}"
            },
            status_code=200
        )
    except Exception as e:
        import traceback
        error_details = traceback.format_exc()
        logger.error(f"PDF 업로드 오류: {str(e)}\n{error_details}")
        return JSONResponse(
            content={"success": False, "message": str(e)}, 
            status_code=500
        )

# 텍스트 파일을 PDF로 변환하는 함수
async def convert_text_to_pdf(text_content: str, title: str) -> str:
    try:
        # 제목에서 유효한 파일명 생성
        import re
        safe_title = re.sub(r'[^\w\-_\. ]', '_', title)
        if not safe_title:
            safe_title = "aibook"
        
        # 타임스탬프 추가로 고유한 파일명 생성
        timestamp = int(time.time())
        filename = f"{safe_title}_{timestamp}.pdf"
        
        # 영구 저장소의 파일 경로
        file_path = PERMANENT_PDF_DIR / filename
        
        # 기본 Helvetica 폰트 사용 (한글 지원 없음)
        from reportlab.lib.pagesizes import letter
        from reportlab.pdfgen import canvas
        
        # PDF 생성
        c = canvas.Canvas(str(file_path), pagesize=letter)
        
        # 페이지 크기 설정
        page_width, page_height = letter
        
        # 제목 추가
        c.setFont("Helvetica-Bold", 16)
        c.drawCentredString(page_width/2, page_height - 50, title)
        
        # 본문 텍스트 추가
        c.setFont("Helvetica", 11)
        y_position = page_height - 100
        line_height = 14
        
        # 텍스트를 단락으로 분리
        paragraphs = text_content.split('\n\n')
        
        for para in paragraphs:
            if not para.strip():
                continue
                
            # 단락 내 줄 바꿈 처리
            lines = para.split('\n')
            for line in lines:
                # 한 줄의 최대 문자 수
                max_chars_per_line = 80
                
                # 긴 줄 감싸기
                import textwrap
                wrapped_lines = textwrap.wrap(line, width=max_chars_per_line)
                
                for wrapped_line in wrapped_lines:
                    # 페이지 바꿈 확인
                    if y_position < 50:
                        c.showPage()
                        c.setFont("Helvetica", 11)
                        y_position = page_height - 50
                    
                    try:
                        # ASCII 문자만 처리
                        ascii_line = ''.join(c if ord(c) < 128 else ' ' for c in wrapped_line)
                        c.drawString(50, y_position, ascii_line)
                    except:
                        # 오류 발생 시 공백으로 대체
                        c.drawString(50, y_position, "[텍스트 변환 오류]")
                    
                    y_position -= line_height
                
            # 단락 간 간격
            y_position -= 10
        
        # PDF 저장
        c.save()
        
        # 메인 디렉토리에도 복사
        shutil.copy2(file_path, PDF_DIR / filename)
        
        # PDF ID 생성 및 메타데이터 저장
        pdf_id = generate_pdf_id(filename)
        pdf_metadata[pdf_id] = str(file_path)
        save_pdf_metadata()
        
        # 백그라운드에서 캐싱 시작
        asyncio.create_task(cache_pdf(str(file_path)))
        
        return {
            "path": str(file_path),
            "filename": filename,
            "id": pdf_id
        }
        
    except Exception as e:
        logger.error(f"텍스트를 PDF로 변환 중 오류: {e}")
        raise e


# AI를 사용하여 텍스트를 더 구조화된 형식으로 변환 (OpenAI 제거 버전)
async def enhance_text_with_ai(text_content: str, title: str) -> str:
    # 원본 텍스트 그대로 반환 (AI 향상 기능 비활성화)
    return text_content    



# 텍스트 파일을 PDF로 변환하는 엔드포인트
@app.post("/api/text-to-pdf")
async def text_to_pdf(file: UploadFile = File(...)):
    try:
        # 지원하는 파일 형식 확인
        filename = file.filename.lower()
        if not (filename.endswith('.txt') or filename.endswith('.docx') or filename.endswith('.doc')):
            return JSONResponse(
                content={"success": False, "message": "지원하는 파일 형식은 .txt, .docx, .doc입니다."}, 
                status_code=400
            )
        
        # 파일 내용 읽기
        content = await file.read()
        
        # 파일 타입에 따라 텍스트 추출
        if filename.endswith('.txt'):
            # 인코딩 자동 감지 시도
            encodings = ['utf-8', 'euc-kr', 'cp949', 'latin1']
            text_content = None
            
            for encoding in encodings:
                try:
                    text_content = content.decode(encoding, errors='strict')
                    logger.info(f"텍스트 파일 인코딩 감지: {encoding}")
                    break
                except UnicodeDecodeError:
                    continue
            
            if text_content is None:
                # 모든 인코딩 시도 실패 시 기본적으로 UTF-8로 시도하고 오류는 대체 문자로 처리
                text_content = content.decode('utf-8', errors='replace')
                logger.warning("텍스트 파일 인코딩을 감지할 수 없어 UTF-8으로 시도합니다.")
                
        elif filename.endswith('.docx') or filename.endswith('.doc'):
            # 임시 파일로 저장
            with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(filename)[1]) as temp_file:
                temp_file.write(content)
                temp_path = temp_file.name
            
            try:
                # docx2txt로 텍스트 추출
                text_content = docx2txt.process(temp_path)
            finally:
                # 임시 파일 삭제
                os.unlink(temp_path)
        
        # 파일명에서 제목 추출 (확장자 제외)
        title = os.path.splitext(filename)[0]
        
        # AI로 텍스트 내용 향상
        enhanced_text = await enhance_text_with_ai(text_content, title)
        
        # 텍스트를 PDF로 변환
        pdf_info = await convert_text_to_pdf(enhanced_text, title)
        
        return JSONResponse(
            content={
                "success": True, 
                "path": pdf_info["path"], 
                "name": os.path.splitext(pdf_info["filename"])[0],
                "id": pdf_info["id"],
                "viewUrl": f"/view/{pdf_info['id']}"
            },
            status_code=200
        )
    except Exception as e:
        import traceback
        error_details = traceback.format_exc()
        logger.error(f"텍스트를 PDF로 변환 중 오류: {str(e)}\n{error_details}")
        return JSONResponse(
            content={"success": False, "message": str(e)}, 
            status_code=500
        )

# 관리자 인증 엔드포인트
@app.post("/api/admin-login")
async def admin_login(password: str = Form(...)):
    if password == ADMIN_PASSWORD:
        return {"success": True}
    return {"success": False, "message": "인증 실패"}

# 관리자용 PDF 삭제 엔드포인트
@app.delete("/api/admin/delete-pdf")
async def delete_pdf(path: str):
    try:
        pdf_file = pathlib.Path(path)
        if not pdf_file.exists():
            return {"success": False, "message": "파일을 찾을 수 없습니다"}
        
        # PDF 파일명 가져오기
        filename = pdf_file.name
        
        # PDF 파일 삭제 (영구 저장소에서)
        pdf_file.unlink()
        
        # 메인 디렉토리에서도 동일한 파일이 있으면 삭제 (버그 수정)
        main_file_path = PDF_DIR / filename
        if main_file_path.exists():
            main_file_path.unlink()
        
        # 관련 캐시 파일 삭제
        pdf_name = pdf_file.stem
        cache_path = get_cache_path(pdf_name)
        if cache_path.exists():
            cache_path.unlink()
            
        # 캐시 메모리에서도 제거
        if pdf_name in pdf_cache:
            del pdf_cache[pdf_name]
            
        # 메타데이터에서 해당 파일 ID 제거
        to_remove = []
        for pid, fpath in pdf_metadata.items():
            if os.path.basename(fpath) == filename:
                to_remove.append(pid)
        
        for pid in to_remove:
            del pdf_metadata[pid]
        
        save_pdf_metadata()
            
        return {"success": True}
    except Exception as e:
        logger.error(f"PDF 삭제 오류: {str(e)}")
        return {"success": False, "message": str(e)}

# PDF를 메인 디렉토리에 표시 설정
@app.post("/api/admin/feature-pdf")
async def feature_pdf(path: str):
    try:
        pdf_file = pathlib.Path(path)
        if not pdf_file.exists():
            return {"success": False, "message": "파일을 찾을 수 없습니다"}
        
        # 메인 디렉토리에 복사
        target_path = PDF_DIR / pdf_file.name
        shutil.copy2(pdf_file, target_path)
            
        return {"success": True}
    except Exception as e:
        logger.error(f"PDF 표시 설정 오류: {str(e)}")
        return {"success": False, "message": str(e)}

# PDF를 메인 디렉토리에서 제거 (영구 저장소에서는 유지)
@app.delete("/api/admin/unfeature-pdf")
async def unfeature_pdf(path: str):
    try:
        pdf_name = pathlib.Path(path).name
        target_path = PDF_DIR / pdf_name
        
        if target_path.exists():
            target_path.unlink()
            
        return {"success": True}
    except Exception as e:
        logger.error(f"PDF 표시 해제 오류: {str(e)}")
        return {"success": False, "message": str(e)}

# 직접 PDF 뷰어 URL 접근용 라우트
@app.get("/view/{pdf_id}")
async def view_pdf_by_id(pdf_id: str):
    # PDF ID 유효한지 확인
    pdf_path = get_pdf_path_by_id(pdf_id)
    
    if not pdf_path:
        # 일단 모든 PDF 메타데이터를 다시 로드하고 재시도
        load_pdf_metadata()
        pdf_path = get_pdf_path_by_id(pdf_id)
        
        if not pdf_path:
            # 모든 PDF 파일을 직접 스캔하여 유사한 이름 찾기
            for file_path in get_pdf_files() + get_permanent_pdf_files():
                name_part = pdf_id.split('_')[0] if '_' in pdf_id else pdf_id
                if file_path.stem.startswith(name_part):
                    pdf_metadata[pdf_id] = str(file_path)
                    save_pdf_metadata()
                    pdf_path = str(file_path)
                    break
    
    if not pdf_path:
        return HTMLResponse(
            content=f"<html><body><h1>PDF를 찾을 수 없습니다</h1><p>ID: {pdf_id}</p><a href='/'>홈으로 돌아가기</a></body></html>",
            status_code=404
        )
    
    # 메인 페이지로 리다이렉트하되, PDF ID 파라미터 추가
    return get_html_content(pdf_id=pdf_id)

# HTML 파일 읽기 함수
def get_html_content(pdf_id: str = None):
    html_path = BASE / "flipbook_template.html"
    content = ""
    if html_path.exists():
        with open(html_path, "r", encoding="utf-8") as f:
            content = f.read()
    else:
        content = HTML  # 기본 HTML 사용
    
    # PDF ID가 제공된 경우, 자동 로드 스크립트 추가
    if pdf_id:
        auto_load_script = f"""
        <script>
            // 페이지 로드 시 자동으로 해당 PDF 열기
            document.addEventListener('DOMContentLoaded', async function() {{
                try {{
                    // PDF 정보 가져오기
                    const response = await fetch('/api/pdf-info-by-id/{pdf_id}');
                    const pdfInfo = await response.json();
                    
                    if (pdfInfo.exists && pdfInfo.path) {{
                        // 약간의 지연 후 PDF 뷰어 열기 (UI가 준비된 후)
                        setTimeout(() => {{
                            openPdfById('{pdf_id}', pdfInfo.path, pdfInfo.cached);
                        }}, 500);
                    }} else {{
                        showError("요청한 PDF를 찾을 수 없습니다.");
                    }}
                }} catch (e) {{
                    console.error("자동 PDF 로드 오류:", e);
                }}
            }});
        </script>
        """
        
        # body 종료 태그 전에 스크립트 삽입
        content = content.replace("</body>", auto_load_script + "</body>")
    
    return HTMLResponse(content=content)

@app.get("/", response_class=HTMLResponse)
async def root(request: Request, pdf_id: Optional[str] = Query(None)):
    # PDF ID가 쿼리 파라미터로 제공된 경우 /view/{pdf_id}로 리다이렉트
    if pdf_id:
        return RedirectResponse(url=f"/view/{pdf_id}")
    return get_html_content()

# HTML 문자열 (AI 버튼 및 챗봇 UI 추가)
HTML = """
<!doctype html>
<html lang="ko">
<head>
  <meta charset="utf-8">
  <title>FlipBook Space</title>
  <link rel="stylesheet" href="/static/flipbook.css">
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
  <script src="/static/three.js"></script>
  <script src="/static/iscroll.js"></script>
  <script src="/static/mark.js"></script>
  <script src="/static/mod3d.js"></script>
  <script src="/static/pdf.js"></script>
  <script src="/static/flipbook.js"></script>
  <script src="/static/flipbook.book3.js"></script>
  <script src="/static/flipbook.scroll.js"></script>
  <script src="/static/flipbook.swipe.js"></script>
  <script src="/static/flipbook.webgl.js"></script>
  <style>
  /* 전체 사이트 파스텔톤 테마 */
  :root {
    --primary-color: #a5d8ff; /* 파스텔 블루 */
    --secondary-color: #ffd6e0; /* 파스텔 핑크 */
    --tertiary-color: #c3fae8; /* 파스텔 민트 */
    --accent-color: #d0bfff; /* 파스텔 퍼플 */
    --ai-color: #86e8ab; /* AI 버튼 색상 */
    --ai-hover: #65d68a; /* AI 호버 색상 */
    --bg-color: #f8f9fa; /* 밝은 배경 */
    --text-color: #495057; /* 부드러운 어두운 색 */
    --card-bg: #ffffff; /* 카드 배경색 */
    --shadow-sm: 0 2px 8px rgba(0,0,0,0.05);
    --shadow-md: 0 4px 12px rgba(0,0,0,0.08);
    --shadow-lg: 0 8px 24px rgba(0,0,0,0.12);
    --radius-sm: 8px;
    --radius-md: 12px;
    --radius-lg: 16px;
    --transition: all 0.3s ease;
  }


    body {
      margin: 0;
      background: var(--bg-color);
      font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
      color: var(--text-color);
      /* 새로운 퍼플 계통 고급스러운 그라디에이션 배경 */
      background-image: linear-gradient(135deg, #2a0845 0%, #6441a5 50%, #c9a8ff 100%);
      background-attachment: fixed;
    }

    /* 뷰어 모드일 때 배경 변경 */
    .viewer-mode {
      background-image: linear-gradient(135deg, #30154e 0%, #6b47ad 50%, #d5b8ff 100%) !important;
    }

  /* 헤더 제목 제거 및 Home 버튼 레이어 처리 */
  .floating-home, .floating-ai {
    position: fixed;
    top: 20px;
    left: 20px;
    width: 60px;
    height: 60px;
    border-radius: 50%;
    background: rgba(255, 255, 255, 0.9);
    backdrop-filter: blur(10px);
    box-shadow: var(--shadow-md);
    z-index: 9999;
    display: flex;
    justify-content: center;
    align-items: center;
    cursor: pointer;
    transition: var(--transition);
    overflow: hidden;
  }
  
  .floating-ai {
    top: 90px; /* Home 버튼 아래에 위치 */
    background: rgba(134, 232, 171, 0.9); /* AI 버튼 색상 */
  }
  
  .floating-home:hover, .floating-ai:hover {
    transform: scale(1.05);
    box-shadow: var(--shadow-lg);
  }
  
  .floating-home .icon, .floating-ai .icon {
    display: flex;
    justify-content: center;
    align-items: center;
    width: 100%;
    height: 100%;
    font-size: 22px;
    color: var(--primary-color);
    transition: var(--transition);
  }
  
  .floating-ai .icon {
    color: white;
  }
  
  .floating-home:hover .icon {
    color: #8bc5f8;
  }
  
  .floating-ai:hover .icon {
    color: #ffffff;
  }
  
  .floating-home .title, .floating-ai .title {
    position: absolute;
    left: 70px;
    background: rgba(255, 255, 255, 0.95);
    padding: 8px 20px;
    border-radius: 20px;
    box-shadow: var(--shadow-sm);
    font-weight: 600;
    font-size: 14px;
    white-space: nowrap;
    pointer-events: none;
    opacity: 0;
    transform: translateX(-10px);
    transition: all 0.3s ease;
  }
  
  .floating-home:hover .title, .floating-ai:hover .title {
    opacity: 1;
    transform: translateX(0);
  }

  /* 관리자 버튼 스타일 */
  #adminButton {
    position: fixed;
    top: 20px;
    right: 20px;
    background: rgba(255, 255, 255, 0.9);
    backdrop-filter: blur(10px);
    box-shadow: var(--shadow-md);
    border-radius: 30px;
    padding: 8px 20px;
    display: flex;
    align-items: center;
    font-weight: 600;
    font-size: 14px;
    cursor: pointer;
    transition: var(--transition);
    z-index: 9999;
  }
  
  #adminButton i {
    margin-right: 8px;
    color: var(--accent-color);
  }
  
  #adminButton:hover {
    transform: translateY(-3px);
    box-shadow: var(--shadow-lg);
  }

  /* 관리자 로그인 모달 */
  .modal {
    display: none;
    position: fixed;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    background: rgba(0, 0, 0, 0.5);
    backdrop-filter: blur(5px);
    z-index: 10000;
    align-items: center;
    justify-content: center;
  }
  
  .modal-content {
    background: white;
    border-radius: var(--radius-md);
    padding: 30px;
    width: 90%;
    max-width: 400px;
    box-shadow: var(--shadow-lg);
    text-align: center;
  }
  
  .modal-content h2 {
    margin-top: 0;
    color: var(--accent-color);
    margin-bottom: 20px;
  }
  
  .modal-content input {
    width: 100%;
    padding: 12px;
    margin-bottom: 20px;
    border: 1px solid #ddd;
    border-radius: var(--radius-sm);
    font-size: 16px;
    box-sizing: border-box;
  }
  
  .modal-content button {
    padding: 10px 20px;
    border: none;
    border-radius: var(--radius-sm);
    background: var(--accent-color);
    color: white;
    font-weight: 600;
    cursor: pointer;
    margin: 0 5px;
    transition: var(--transition);
  }
  
  .modal-content button:hover {
    opacity: 0.9;
    transform: translateY(-2px);
  }
  
  .modal-content #adminLoginClose {
    background: #f1f3f5;
    color: var(--text-color);
  }

  #home, #viewerPage, #adminPage {
    padding-top: 100px;
    max-width: 1200px;
    margin: 0 auto;
    padding-bottom: 60px;
    padding-left: 30px;
    padding-right: 30px;
    position: relative;
  }

  /* 업로드 버튼 스타일 */
  .upload-container {
    display: flex;
    margin-bottom: 30px;
    justify-content: center;
  }

  button.upload {
    all: unset;
    cursor: pointer;
    padding: 12px 20px;
    border-radius: var(--radius-md);
    background: white;
    margin: 0 10px;
    font-weight: 500;
    display: flex;
    align-items: center;


box-shadow: var(--shadow-sm);
    transition: var(--transition);
    position: relative;
    overflow: hidden;
  }

  button.upload::before {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    background: linear-gradient(120deg, var(--primary-color) 0%, var(--secondary-color) 100%);
    opacity: 0.08;
    z-index: -1;
  }

  button.upload:hover {
    transform: translateY(-3px);
    box-shadow: var(--shadow-md);
  }

  button.upload:hover::before {
    opacity: 0.15;
  }

  button.upload i {
    margin-right: 8px;
    font-size: 20px;
  }

  /* 그리드 및 카드 스타일 */
  .grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
    gap: 24px;
    margin-top: 36px;
  }

  .card {
    background: var(--card-bg);
    border-radius: var(--radius-md);
    cursor: pointer;
    box-shadow: var(--shadow-sm);
    width: 100%;
    height: 280px;
    position: relative;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    transition: var(--transition);
    overflow: hidden;
  }

  .card::before {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    background: linear-gradient(135deg, var(--secondary-color) 0%, var(--primary-color) 100%);
    opacity: 0.06;
    z-index: 1;
  }

  .card::after {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 30%;
    background: linear-gradient(to bottom, rgba(255,255,255,0.8) 0%, rgba(255,255,255,0) 100%);
    z-index: 2;
  }

  .card img {
    width: 65%;
    height: auto;
    object-fit: contain;
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -65%);
    border: 1px solid rgba(0,0,0,0.05);
    box-shadow: 0 4px 15px rgba(0,0,0,0.08);
    z-index: 3;
    transition: var(--transition);
  }

  .card:hover {
    transform: translateY(-5px);
    box-shadow: var(--shadow-md);
  }

  .card:hover img {
    transform: translate(-50%, -65%) scale(1.03);
    box-shadow: 0 8px 20px rgba(0,0,0,0.12);
  }

  .card p {
    position: absolute;
    bottom: 20px;
    left: 50%;
    transform: translateX(-50%);
    background: rgba(255, 255, 255, 0.9);
    padding: 8px 16px;
    border-radius: 30px;
    box-shadow: 0 2px 10px rgba(0,0,0,0.05);
    width: 80%;
    text-align: center;
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    font-size: 14px;
    font-weight: 500;
    color: var(--text-color);
    z-index: 4;
    transition: var(--transition);
  }

  .card:hover p {
    background: rgba(255, 255, 255, 0.95);
    box-shadow: 0 4px 12px rgba(0,0,0,0.08);
  }

  /* 캐시 상태 뱃지 */
  .cached-status {
    position: absolute;
    top: 10px;
    right: 10px;
    background: var(--accent-color);
    color: white;
    font-size: 11px;
    padding: 3px 8px;
    border-radius: 12px;
    z-index: 5;
    box-shadow: var(--shadow-sm);
  }
  
  /* 관리자 카드 추가 스타일 */
  .admin-card {
    height: 300px;
  }
  
  .admin-card .card-inner {
    width: 100%;
    height: 100%;
    position: relative;
    display: flex;
    flex-direction: column;
    align-items: center;
  }
  
  .delete-btn, .feature-btn, .unfeature-btn {
    position: absolute;
    bottom: 60px;
    left: 50%;
    transform: translateX(-50%);
    background: #ff7675;
    color: white;
    border: none;
    border-radius: 20px;
    padding: 5px 15px;
    font-size: 12px;
    cursor: pointer;
    z-index: 10;
    transition: var(--transition);
  }
  
  .feature-btn {
    bottom: 95px;
    background: #74b9ff;
  }
  
  .unfeature-btn {
    bottom: 95px;
    background: #a29bfe;
  }
  
  .delete-btn:hover, .feature-btn:hover, .unfeature-btn:hover {
    opacity: 0.9;
    transform: translateX(-50%) scale(1.05);
  }

  /* 뷰어 스타일 */
  #viewer {
    width: 90%;
    height: 90vh;
    max-width: 90%;
    margin: 0;
    background: var(--card-bg);
    border: none;
    border-radius: var(--radius-lg);
    position: fixed;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
    z-index: 1000;
    box-shadow: var(--shadow-lg);
    max-height: calc(90vh - 40px);
    aspect-ratio: auto;
    object-fit: contain;
    overflow: hidden;
  }

  /* FlipBook 컨트롤바 스타일 */
  .flipbook-container .fb3d-menu-bar {
    z-index: 2000 !important;
    opacity: 1 !important;
    bottom: 0 !important;
    background-color: rgba(255,255,255,0.9) !important;
    backdrop-filter: blur(10px) !important;
    border-radius: 0 0 var(--radius-lg) var(--radius-lg) !important;
    padding: 12px 0 !important;
    box-shadow: 0 -4px 20px rgba(0,0,0,0.1) !important;
  }

  .flipbook-container .fb3d-menu-bar > ul > li > img,
  .flipbook-container .fb3d-menu-bar > ul > li > div {
    opacity: 1 !important;
    transform: scale(1.2) !important;
    filter: drop-shadow(0 2px 3px rgba(0,0,0,0.1)) !important;
  }

  .flipbook-container .fb3d-menu-bar > ul > li {
    margin: 0 12px !important;
  }

  /* 메뉴 툴팁 스타일 */
  .flipbook-container .fb3d-menu-bar > ul > li > span {
    background-color: rgba(0,0,0,0.7) !important;
    color: white !important;
    border-radius: var(--radius-sm) !important;
    padding: 8px 12px !important;
    font-size: 13px !important;
    bottom: 55px !important;
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif !important;
    letter-spacing: 0.3px !important;
  }

  /* 뷰어 모드일 때 배경 오버레이 */
  .viewer-mode {
    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%) !important;
  }

  /* 뷰어 페이지 배경 */
  #viewerPage {
    background: transparent;
  }

  /* 로딩 애니메이션 */
  @keyframes spin {
    0% { transform: rotate(0deg); }
    100% { transform: rotate(360deg); }
  }

  .loading-spinner {
    border: 4px solid rgba(255,255,255,0.3);
    border-top: 4px solid var(--primary-color);
    border-radius: 50%;
    width: 50px;
    height: 50px;
    margin: 0 auto;
    animation: spin 1.5s ease-in-out infinite;
  }

  .loading-container {
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
    text-align: center;
    background: rgba(255, 255, 255, 0.85);
    backdrop-filter: blur(10px);
    padding: 30px;
    border-radius: var(--radius-md);
    box-shadow: var(--shadow-md);
    z-index: 9999;
  }

  .loading-text {
    margin-top: 20px;
    font-size: 16px;
    color: var(--text-color);
    font-weight: 500;
  }

  /* 페이지 전환 애니메이션 */
  @keyframes fadeIn {
    from { opacity: 0; }
    to { opacity: 1; }
  }

  .fade-in {
    animation: fadeIn 0.5s ease-out;
  }

  /* 추가 스타일 */
  .section-title {
    font-size: 1.3rem;
    font-weight: 600;
    margin: 30px 0 15px;
    color: var(--text-color);
  }

  .no-projects {
    text-align: center;
    margin: 40px 0;
    color: var(--text-color);
    font-size: 16px;
  }

  /* 프로그레스 바 */
  .progress-bar-container {
    width: 100%;
    height: 6px;
    background-color: rgba(0,0,0,0.1);
    border-radius: 3px;
    margin-top: 15px;
    overflow: hidden;
  }

  .progress-bar {
    height: 100%;
    background: linear-gradient(to right, var(--primary-color), var(--accent-color));
    border-radius: 3px;
    transition: width 0.3s ease;
  }

  /* 헤더 로고 및 타이틀 */
  .library-header {
    position: fixed;
    top: 12px;
    left: 0;
    right: 0;
    text-align: center;
    z-index: 100;
    pointer-events: none;
  }
  
.library-header .title {
  display: inline-block;
  padding: 8px 24px; /* 패딩 축소 */
  background: rgba(255, 255, 255, 0.85);
  backdrop-filter: blur(10px);
  border-radius: 25px; /* 테두리 모서리 축소 */
  box-shadow: var(--shadow-md);
  font-size: 1.25rem; /* 글자 크기 축소 (1.5rem에서 1.25rem으로) */
  font-weight: 600;
  background-image: linear-gradient(120deg, #8e74eb 0%, #9d66ff 100%); /* 제목 색상도 바탕화면과 어울리게 변경 */
  -webkit-background-clip: text;
  background-clip: text;
  color: transparent;
  pointer-events: all;
}
  
  /* 점진적 로딩 표시 */
  .loading-pages {
    position: absolute;
    bottom: 20px;
    left: 50%;
    transform: translateX(-50%);
    background: rgba(255, 255, 255, 0.9);
    padding: 10px 20px;
    border-radius: 20px;
    box-shadow: var(--shadow-md);
    font-size: 14px;
    color: var(--text-color);
    z-index: 9998;
    text-align: center;
  }
  
  /* 관리자 페이지 스타일 */
  #adminPage {
    color: white;
    max-width: 1400px;
  }
  
  #adminPage h1 {
    font-size: 2rem;
    margin-bottom: 30px;
    text-align: center;
    background-image: linear-gradient(120deg, #e0c3fc 0%, #8ec5fc 100%);
    -webkit-background-clip: text;
    background-clip: text;
    color: transparent;
  }
  
  #adminBackButton {
    position: absolute;
    top: 20px;
    left: 20px;
    background: rgba(255, 255, 255, 0.9);
    backdrop-filter: blur(10px);
    box-shadow: var(--shadow-md);
    border: none;
    border-radius: 30px;
    padding: 8px 20px;
    display: flex;
    align-items: center;
    font-weight: 600;
    font-size: 14px;
    cursor: pointer;
    transition: var(--transition);
  }
  
  #adminBackButton:hover {
    transform: translateY(-3px);
    box-shadow: var(--shadow-lg);
  }
  
  /* 관리자 그리드 */
  #adminGrid {
    grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
  }

  /* AI 챗봇 UI 스타일 */
  #aiChatContainer {
    display: none;
    position: fixed;
    top: 0;
    right: 0;
    width: 400px;
    height: 100%;
    background: rgba(255, 255, 255, 0.95);
    backdrop-filter: blur(10px);
    box-shadow: -5px 0 20px rgba(0, 0, 0, 0.1);
    z-index: 9999;
    transition: all 0.3s ease;
    transform: translateX(100%);
    padding: 20px;
    box-sizing: border-box;
    display: flex;
    flex-direction: column;
  }
  
  #aiChatContainer.active {
    transform: translateX(0);
  }
  
  #aiChatHeader {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 15px;
    padding-bottom: 15px;
    border-bottom: 1px solid rgba(0, 0, 0, 0.1);
  }
  
  #aiChatHeader h3 {
    margin: 0;
    color: #333;
    font-size: 18px;
    display: flex;
    align-items: center;
  }
  
  #aiChatHeader h3 i {
    margin-right: 10px;
    color: var(--ai-color);
  }
  
  #aiChatClose {
    background: none;
    border: none;
    cursor: pointer;
    font-size: 18px;
    color: #666;
    transition: var(--transition);
  }
  
  #aiChatClose:hover {
    color: #333;
    transform: scale(1.1);
  }
  
  #aiChatMessages {
    flex: 1;
    overflow-y: auto;
    padding: 10px 0;
    margin-bottom: 15px;
  }
  
  .chat-message {
    margin-bottom: 15px;
    display: flex;
    align-items: flex-start;
  }
  
  .chat-message.user {
    flex-direction: row-reverse;
  }
  
  .chat-avatar {
    width: 35px;
    height: 35px;
    border-radius: 50%;
    display: flex;
    justify-content: center;
    align-items: center;
    margin-right: 10px;
    flex-shrink: 0;
  }
  
  .chat-message.user .chat-avatar {
    margin-right: 0;
    margin-left: 10px;
    background: var(--primary-color);
    color: white;
  }
  
  .chat-message.ai .chat-avatar {
    background: var(--ai-color);
    color: white;
  }
  
  .chat-content {
    background: #f1f1f1;
    padding: 12px 15px;
    border-radius: 18px;
    max-width: 75%;
    word-break: break-word;
    position: relative;
    font-size: 14px;
    line-height: 1.4;
  }
  
  .chat-message.user .chat-content {
    background: var(--primary-color);
    color: white;
    border-bottom-right-radius: 4px;
  }
  
  .chat-message.ai .chat-content {
    background: #f1f1f1;
    color: #333;
    border-bottom-left-radius: 4px;
  }
  
  #aiChatForm {
    display: flex;
    border-top: 1px solid rgba(0, 0, 0, 0.1);
    padding-top: 15px;
  }
  
  #aiChatInput {
    flex: 1;
    padding: 12px 15px;
    border: 1px solid #ddd;
    border-radius: 25px;
    font-size: 14px;
    outline: none;
    transition: var(--transition);
  }
  
  #aiChatInput:focus {
    border-color: var(--ai-color);
    box-shadow: 0 0 0 2px rgba(134, 232, 171, 0.2);
  }
  
  #aiChatSubmit {
    background: var(--ai-color);
    border: none;
    color: white;
    width: 45px;
    height: 45px;
    border-radius: 50%;
    margin-left: 10px;
    display: flex;
    justify-content: center;
    align-items: center;
    cursor: pointer;
    transition: var(--transition);
  }
  
  #aiChatSubmit:hover {
    background: var(--ai-hover);
    transform: scale(1.05);
  }
  
  #aiChatSubmit:disabled {
    background: #ccc;
    cursor: not-allowed;
  }
  
  .typing-indicator {
    display: flex;
    align-items: center;
    margin-top: 5px;
    font-size: 12px;
    color: #666;
  }
  
  .typing-indicator span {
    height: 8px;
    width: 8px;
    background: var(--ai-color);
    border-radius: 50%;
    display: inline-block;
    margin-right: 3px;
    animation: typing 1s infinite;
  }
  
  .typing-indicator span:nth-child(2) {
    animation-delay: 0.2s;
  }
  
  .typing-indicator span:nth-child(3) {
    animation-delay: 0.4s;
  }
  
  @keyframes typing {
    0% { transform: translateY(0); }
    50% { transform: translateY(-5px); }
    100% { transform: translateY(0); }
  }
  
  .chat-time {
    font-size: 10px;
    color: #999;
    margin-top: 5px;
    text-align: right;
  }
  
  /* 코드 블록 스타일 */
  .chat-content pre {
    background: rgba(0, 0, 0, 0.05);
    padding: 10px;
    border-radius: 5px;
    overflow-x: auto;
    font-family: monospace;
    font-size: 12px;
    margin: 10px 0;
  }
  
  /* 마크다운 스타일 */
  .chat-content strong {
    font-weight: bold;
  }
  
  .chat-content em {
    font-style: italic;
  }
  
  .chat-content ul, .chat-content ol {
    margin-left: 20px;
    margin-top: 5px;
    margin-bottom: 5px;
  }
  
  /* 공유 버튼 */
  #shareChat {
    padding: 8px 15px;
    background: #f1f1f1;
    border: none;
    border-radius: 20px;
    font-size: 12px;
    color: #666;
    cursor: pointer;
    margin-top: 5px;
    transition: var(--transition);
  }
  
  #shareChat:hover {
    background: #ddd;
  }

  /* 반응형 디자인 */
  @media (max-width: 768px) {
    .grid {
      grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
      gap: 16px;
    }
    
    .card {
      height: 240px;
    }
    
    .library-header .title {
      font-size: 1.25rem;
      padding: 10px 20px;
    }
    
    .floating-home, .floating-ai {
      width: 50px;
      height: 50px;
    }
    
    .floating-home .icon, .floating-ai .icon {
      font-size: 18px;
    }
    
    #adminButton {
      padding: 6px 15px;
      font-size: 12px;
    }
    
    #aiChatContainer {
      width: 100%;
    }
  }
  </style>
</head>
<body>
  <!-- 제목을 Home 버튼과 함께 레이어로 처리 -->
  <div id="homeButton" class="floating-home" style="display:none;">
    <div class="icon"><i class="fas fa-home"></i></div>
    <div class="title">홈으로 돌아가기</div>
  </div>
  
  <!-- AI 버튼 추가 -->
  <div id="aiButton" class="floating-ai" style="display:none;">
    <div class="icon"><i class="fas fa-robot"></i></div>
    <div class="title">AI 어시스턴트</div>
  </div>
  
  <!-- AI 챗봇 컨테이너 -->
  <div id="aiChatContainer">
    <div id="aiChatHeader">
      <h3><i class="fas fa-robot"></i> AI 어시스턴트</h3>
      <button id="aiChatClose"><i class="fas fa-times"></i></button>
    </div>
    <div id="aiChatMessages"></div>
    <form id="aiChatForm">
      <input type="text" id="aiChatInput" placeholder="PDF에 대해 질문하세요..." autocomplete="off">
      <button type="submit" id="aiChatSubmit"><i class="fas fa-paper-plane"></i></button>
    </form>
  </div>
  
  <!-- 관리자 버튼 -->
  <div id="adminButton">
    <i class="fas fa-cog"></i> Admin
  </div>
  
  <!-- 관리자 로그인 모달 -->
  <div id="adminLoginModal" class="modal">
    <div class="modal-content">
      <h2>관리자 로그인</h2>
      <input type="password" id="adminPasswordInput" placeholder="관리자 비밀번호">
      <div>
        <button id="adminLoginButton">로그인</button>
        <button id="adminLoginClose">취소</button>
      </div>
    </div>
  </div>
  
  <!-- 센터 정렬된 타이틀 -->
  <div class="library-header">
    <div class="title">AI FlipBook Maker</div>
  </div>

  <section id="home" class="fade-in">
    <div class="upload-container">
      <button class="upload" id="pdfUploadBtn">
        <i class="fas fa-file-pdf"></i> PDF Upload
      </button>
      <button class="upload" id="textToAIBookBtn">
        <i class="fas fa-file-alt"></i> Text to AI-Book
      </button>
      <input id="pdfInput" type="file" accept="application/pdf" style="display:none">
      <input id="textInput" type="file" accept=".txt,.docx,.doc" style="display:none">
    </div>
    
    <div class="section-title">Projects</div>
    <div class="grid" id="grid">
      <!-- 카드가 여기에 동적으로 추가됩니다 -->
    </div>
    <div id="noProjects" class="no-projects" style="display: none;">
      프로젝트가 없습니다. PDF를 추가하여 시작하세요.
    </div>
  </section>

  <section id="viewerPage" style="display:none">
    <div id="viewer"></div>
    <div id="loadingPages" class="loading-pages" style="display:none;">페이지 로딩 중... <span id="loadingPagesCount">0/0</span></div>
  </section>
  
  <!-- 관리자 페이지 -->
  <section id="adminPage" style="display:none" class="fade-in">
    <h1>관리자 페이지</h1>
    <button id="adminBackButton"><i class="fas fa-arrow-left"></i> 뒤로 가기</button>
    
    <div class="section-title">저장된 PDF 목록</div>
    <div class="grid" id="adminGrid">
      <!-- 관리자 PDF 카드가 여기에 동적으로 추가됩니다 -->
    </div>
    <div id="noAdminProjects" class="no-projects" style="display: none;">
      저장된 PDF가 없습니다. PDF를 업로드하여 시작하세요.
    </div>
  </section>

<script>
    let projects=[], fb=null;
    const grid=document.getElementById('grid'), viewer=document.getElementById('viewer');
    pdfjsLib.GlobalWorkerOptions.workerSrc='/static/pdf.worker.js';

    // 서버에서 미리 로드된 PDF 프로젝트
    let serverProjects = [];
    
    // 현재 페이지 로딩 상태
    let currentLoadingPdfPath = null;
    let pageLoadingInterval = null;
    
    // 현재 열린 PDF의 ID
    let currentPdfId = null;

    // 오디오 컨텍스트와 초기화 상태 관리
    let audioInitialized = false;
    let audioContext = null;

    // AI 챗봇 관련 변수
    let isAiChatActive = false;
    let isAiProcessing = false;
    let hasLoadedSummary = false;

    // 오디오 초기화 함수
    function initializeAudio() {
      if (audioInitialized) return Promise.resolve();
      
      return new Promise((resolve) => {
        // 오디오 컨텍스트 생성 (사용자 상호작용이 필요 없는 초기화)
        audioContext = new (window.AudioContext || window.webkitAudioContext)();
        
        // MP3 로드 및 초기화
        const audio = new Audio('/static/turnPage2.mp3');
        audio.volume = 0.01; // 최소 볼륨으로 설정
        
        // 로드된 오디오 재생 시도 (사용자 상호작용 요구될 수 있음)
        const playPromise = audio.play();
        
        if (playPromise !== undefined) {
          playPromise
            .then(() => {
              // 성공적으로 재생됨 - 즉시 일시정지
              audio.pause();
              audioInitialized = true;
              console.log('오디오 초기화 성공');
              resolve();
            })
            .catch((error) => {
              console.log('자동 오디오 초기화 실패, 사용자 상호작용 필요:', error);
              
              // 사용자 상호작용이 필요한 경우, 이벤트 리스너 추가
              const initOnUserAction = function() {
                const tempAudio = new Audio('/static/turnPage2.mp3');
                tempAudio.volume = 0.01;
                tempAudio.play()
                  .then(() => {
                    tempAudio.pause();
                    audioInitialized = true;
                    console.log('사용자 상호작용으로 오디오 초기화 성공');
                    resolve();
                    
                    // 이벤트 리스너 제거
                    ['click', 'touchstart', 'keydown'].forEach(event => {
                      document.removeEventListener(event, initOnUserAction, { capture: true });
                    });
                  })
                  .catch(e => console.error('오디오 초기화 실패:', e));
              };
              
              // 사용자 상호작용 이벤트에 리스너 추가
              ['click', 'touchstart', 'keydown'].forEach(event => {
                document.addEventListener(event, initOnUserAction, { once: true, capture: true });
              });
              
              // 페이지 로드 직후 사용자에게 오디오 활성화 요청
              if (window.location.pathname.startsWith('/view/')) {
                // 오디오 활성화 안내 메시지 표시 (바로가기 링크로 접속한 경우)
                setTimeout(() => {
                  const audioPrompt = document.createElement('div');
                  audioPrompt.style.position = 'fixed';
                  audioPrompt.style.bottom = '80px';
                  audioPrompt.style.left = '50%';
                  audioPrompt.style.transform = 'translateX(-50%)';
                  audioPrompt.style.backgroundColor = 'rgba(0,0,0,0.7)';
                  audioPrompt.style.color = 'white';
                  audioPrompt.style.padding = '10px 20px';
                  audioPrompt.style.borderRadius = '20px';
                  audioPrompt.style.zIndex = '10000';
                  audioPrompt.style.cursor = 'pointer';
                  audioPrompt.innerHTML = '페이지 어디든 클릭하여 소리 효과 활성화 <i class="fas fa-volume-up"></i>';
                  audioPrompt.id = 'audioPrompt';
                  
                  // 클릭 시 소리 활성화 및 메시지 제거
                  audioPrompt.addEventListener('click', function() {
                    initOnUserAction();
                    audioPrompt.remove();
                  });
                  
                  document.body.appendChild(audioPrompt);
                  
                  // 10초 후 자동으로 숨김
                  setTimeout(() => {
                    if (document.getElementById('audioPrompt')) {
                      document.getElementById('audioPrompt').remove();
                    }
                  }, 10000);
                }, 2000);
              }
            });
        } else {
          // 브라우저가 Promise 기반 재생을 지원하지 않는 경우
          audioInitialized = true;
          resolve();
        }
      });
    }
    
    /* ── 유틸 ── */
    function $id(id){return document.getElementById(id)}
    
    // 현재 시간을 포맷팅하는 함수
    function formatTime() {
      const now = new Date();
      const hours = now.getHours().toString().padStart(2, '0');
      const minutes = now.getMinutes().toString().padStart(2, '0');
      return `${hours}:${minutes}`;
    }
    
    // AI 챗봇 메시지 추가 함수
    function addChatMessage(content, isUser = false) {
      const messagesContainer = $id('aiChatMessages');
      const messageElement = document.createElement('div');
      messageElement.className = `chat-message ${isUser ? 'user' : 'ai'}`;
      
      const currentTime = formatTime();
      
      messageElement.innerHTML = `
        <div class="chat-avatar">
          <i class="fas ${isUser ? 'fa-user' : 'fa-robot'}"></i>
        </div>
        <div class="chat-bubble">
          <div class="chat-content">${content}</div>
          <div class="chat-time">${currentTime}</div>
        </div>
      `;
      
      messagesContainer.appendChild(messageElement);
      messagesContainer.scrollTop = messagesContainer.scrollHeight;
      return messageElement;
    }
    
    // 로딩 표시기 추가 함수
    function addTypingIndicator() {
      const messagesContainer = $id('aiChatMessages');
      const indicatorElement = document.createElement('div');
      indicatorElement.className = 'typing-indicator';
      indicatorElement.innerHTML = `
        <div class="chat-avatar">
          <i class="fas fa-robot"></i>
        </div>
        <div>
          <span></span>
          <span></span>
          <span></span>
        </div>
      `;
      messagesContainer.appendChild(indicatorElement);
      messagesContainer.scrollTop = messagesContainer.scrollHeight;
      return indicatorElement;
    }
    
    // AI 챗봇 토글 함수
    function toggleAiChat(show = true) {
      const aiChatContainer = $id('aiChatContainer');
      
      if (show) {
        // 챗봇 표시
        aiChatContainer.style.display = 'flex';
        setTimeout(() => {
          aiChatContainer.classList.add('active');
        }, 10);
        isAiChatActive = true;
        
        // 처음 열 때 자동 요약 로드
        if (!hasLoadedSummary && currentPdfId) {
          loadPdfSummary();
        }
      } else {
        // 챗봇 숨기기
        aiChatContainer.classList.remove('active');
        setTimeout(() => {
          aiChatContainer.style.display = 'none';
        }, 300);
        isAiChatActive = false;
      }
    }
    
    // PDF 요약 로드 함수
// PDF 요약 로드 함수
async function loadPdfSummary() {
  if (!currentPdfId || isAiProcessing || hasLoadedSummary) return;
  
  try {
    isAiProcessing = true;
    const typingIndicator = addTypingIndicator();
    
    // 서버에 요약 요청
    const response = await fetch(`/api/ai/summarize-pdf/${currentPdfId}`);
    const data = await response.json();
    
    // 로딩 표시기 제거
    typingIndicator.remove();
    
    if (data.error) {
      // 오류 메시지 표시
      addChatMessage(`PDF 요약을 생성하는 중 문제가 발생했습니다: ${data.error}<br><br>계속 질문을 입력하시면 PDF 내용을 기반으로 답변을 시도하겠습니다.`);
      
      // 요약이 실패해도 특정 경우에는 사용자에게 알리고 계속 사용 가능하도록 설정
      if (data.summary) {
        addChatMessage(`<strong>PDF에서 추출한 정보:</strong><br>${data.summary}`);
        hasLoadedSummary = true;
      }
    } else {
      // 환영 메시지와 요약 추가
      addChatMessage(`안녕하세요! 이 PDF에 대해 어떤 것이든 질문해주세요. 제가 도와드리겠습니다.<br><br><strong>PDF 요약:</strong><br>${data.summary}`);
      hasLoadedSummary = true;
    }
  } catch (error) {
    console.error("PDF 요약 로드 오류:", error);
    addChatMessage(`PDF 요약을 로드하는 중 오류가 발생했습니다. 서버 연결을 확인해주세요.<br><br>어떤 질문이든 입력하시면 최선을 다해 답변하겠습니다.`);
  } finally {
    isAiProcessing = false;
  }
}

// 질문 제출 함수
async function submitQuestion(question) {
  if (!currentPdfId || isAiProcessing || !question.trim()) return;
  
  try {
    isAiProcessing = true;
    $id('aiChatSubmit').disabled = true;
    
    // 사용자 메시지 추가
    addChatMessage(question, true);
    
    // 로딩 표시기 추가
    const typingIndicator = addTypingIndicator();
    
    // 서버에 질의 요청
    const response = await fetch(`/api/ai/query-pdf/${currentPdfId}`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ query: question }),
      // 타임아웃 설정 추가
      signal: AbortSignal.timeout(60000) // 60초 타임아웃
    });
    
    const data = await response.json();
    
    // 로딩 표시기 제거
    typingIndicator.remove();
    
    if (data.error) {
      // 오류 메시지에 따라 다른 친절한 안내 제공
      if (data.error.includes("API 키")) {
        addChatMessage("죄송합니다. 현재 AI 서비스에 연결할 수 없습니다. 시스템 관리자에게 API 키 설정을 확인해달라고 요청해주세요.");
      } else if (data.error.includes("연결")) {
        addChatMessage("죄송합니다. AI 서비스에 연결할 수 없습니다. 인터넷 연결을 확인하거나 잠시 후 다시 시도해주세요.");
      } else {
        addChatMessage(`죄송합니다. 질문에 답변하는 중 문제가 발생했습니다: ${data.error}`);
      }
    } else {
      // AI 응답 추가
      addChatMessage(data.answer);
    }
  } catch (error) {
    console.error("질문 제출 오류:", error);
    if (error.name === 'AbortError') {
      addChatMessage("죄송합니다. 응답 시간이 너무 오래 걸려 요청이 취소되었습니다. 인터넷 연결을 확인하거나 더 짧은 질문으로 다시 시도해보세요.");
    } else {
      addChatMessage("죄송합니다. 서버와 통신 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.");
    }
  } finally {
    isAiProcessing = false;
    $id('aiChatSubmit').disabled = false;
    $id('aiChatInput').value = '';
    $id('aiChatInput').focus();
  }
}

    
    // DOM이 로드되면 실행
    document.addEventListener('DOMContentLoaded', function() {
      console.log("DOM 로드 완료, 이벤트 설정 시작");
      
      // 오디오 초기화 시도
      initializeAudio().catch(e => console.warn('오디오 초기화 실패:', e));
      
      // PDF 업로드 버튼
      const pdfBtn = document.getElementById('pdfUploadBtn');
      const pdfInput = document.getElementById('pdfInput');
      
      if (pdfBtn && pdfInput) {
        console.log("PDF 업로드 버튼 찾음");
        
        // 버튼 클릭 시 파일 입력 트리거
        pdfBtn.addEventListener('click', function() {
          console.log("PDF 버튼 클릭됨");
          pdfInput.click();
        });
        
        // 파일 선택 시 처리
        pdfInput.addEventListener('change', function(e) {
          console.log("PDF 파일 선택됨:", e.target.files.length);
          const file = e.target.files[0];
          if (!file) return;
          
          // 서버에 PDF 업로드 (영구 저장소에 저장)
          uploadPdfToServer(file);
        });
      } else {
        console.error("PDF 업로드 요소를 찾을 수 없음");
      }
      
      // 텍스트 업로드 버튼
      const textBtn = document.getElementById('textToAIBookBtn');
      const textInput = document.getElementById('textInput');
      
      if (textBtn && textInput) {
        // 버튼 클릭 시 파일 입력 트리거
        textBtn.addEventListener('click', function() {
          textInput.click();
        });
        
        // 파일 선택 시 처리
        textInput.addEventListener('change', function(e) {
          const file = e.target.files[0];
          if (!file) return;
          
          // 서버에 텍스트 파일 업로드 (영구 저장소에 PDF로 변환하여 저장)
          uploadTextToServer(file);
        });
      }
      
      // 서버 PDF 로드 및 캐시 상태 확인
      loadServerPDFs();
      
      // 캐시 상태를 주기적으로 확인
      setInterval(checkCacheStatus, 3000);
      
      // 관리자 버튼 이벤트 설정
      setupAdminFunctions();
      
      // 홈 버튼 이벤트 설정
      const homeButton = document.getElementById('homeButton');
      if (homeButton) {
        homeButton.addEventListener('click', function() {
          if(fb) {
            fb.destroy();
            viewer.innerHTML = '';
            fb = null;
          }
          toggle(true);
          
          // 로딩 인디케이터 정리
          if (pageLoadingInterval) {
            clearInterval(pageLoadingInterval);
            pageLoadingInterval = null;
          }
          $id('loadingPages').style.display = 'none';
          currentLoadingPdfPath = null;
          currentPdfId = null;
          
          // AI 챗봇 닫기
          toggleAiChat(false);
          hasLoadedSummary = false; // 요약 로드 상태 초기화
        });
      }
      
      // AI 버튼 이벤트 설정
      const aiButton = document.getElementById('aiButton');
      if (aiButton) {
        aiButton.addEventListener('click', function() {
          toggleAiChat(!isAiChatActive);
        });
      }
      
      // AI 챗봇 닫기 버튼
      const aiChatClose = document.getElementById('aiChatClose');
      if (aiChatClose) {
        aiChatClose.addEventListener('click', function() {
          toggleAiChat(false);
        });
      }
      
      // AI 챗봇 폼 제출
      const aiChatForm = document.getElementById('aiChatForm');
      if (aiChatForm) {
        aiChatForm.addEventListener('submit', function(e) {
          e.preventDefault();
          const inputField = document.getElementById('aiChatInput');
          const question = inputField.value.trim();
          
          if (question && !isAiProcessing) {
            submitQuestion(question);
          }
        });
      }
    });
    
    // 서버에 PDF 업로드 함수
    async function uploadPdfToServer(file) {
      try {
        showLoading("PDF 업로드 중...");
        
        const formData = new FormData();
        formData.append('file', file);
        
        const response = await fetch('/api/upload-pdf', {
          method: 'POST',
          body: formData
        });
        
        const result = await response.json();
        
        if (result.success) {
          hideLoading();
          
          // 업로드 성공 시 서버 PDF 리스트 리로드
          await loadServerPDFs();
          
          // 성공 메시지
          showMessage("PDF가 성공적으로 업로드되었습니다! 공유 URL: " + result.viewUrl);
        } else {
          hideLoading();
          showError("업로드 실패: " + (result.message || "알 수 없는 오류"));
        }
      } catch (error) {
        console.error("PDF 업로드 오류:", error);
        hideLoading();
        showError("PDF 업로드 중 오류가 발생했습니다.");
      }
    }

    // 서버에 텍스트 파일을 업로드하여 PDF로 변환하는 함수
    async function uploadTextToServer(file) {
      try {
        showLoading("텍스트 분석 및 PDF 변환 중...");
        
        const formData = new FormData();
        formData.append('file', file);
        
        const response = await fetch('/api/text-to-pdf', {
          method: 'POST',
          body: formData
        });
        
        const result = await response.json();
        
        if (result.success) {
          hideLoading();
          
          // 업로드 성공 시 서버 PDF 리스트 리로드
          await loadServerPDFs();
          
          // 성공 메시지
          showMessage("텍스트가 성공적으로 PDF로 변환되었습니다! 공유 URL: " + result.viewUrl);
        } else {
          hideLoading();
          showError("변환 실패: " + (result.message || "알 수 없는 오류"));
        }
      } catch (error) {
        console.error("텍스트 변환 오류:", error);
        hideLoading();
        showError("텍스트를 PDF로 변환하는 중 오류가 발생했습니다.");
      }
    }

    function addCard(i, thumb, title, isCached = false, pdfId = null) {
      const d = document.createElement('div');
      d.className = 'card fade-in';
      d.onclick = () => open(i);
      
      // PDF ID가 있으면 데이터 속성으로 저장
      if (pdfId) {
        d.dataset.pdfId = pdfId;
      }
      
      // 제목 처리
      const displayTitle = title ? 
        (title.length > 15 ? title.substring(0, 15) + '...' : title) : 
        '프로젝트 ' + (i+1);
      
      // 캐시 상태 뱃지 추가
      const cachedBadge = isCached ? 
        '<div class="cached-status">캐시됨</div>' : '';
      
      // 바로가기 링크 추가 (PDF ID가 있는 경우에만)
      const linkHtml = pdfId ? 
        `<div style="position: absolute; bottom: 55px; left: 50%; transform: translateX(-50%); z-index:5;">
          <a href="/view/${pdfId}" target="_blank" style="color:#4a6ee0; font-size:11px;">Share Link</a>
        </div>` : '';
      
      d.innerHTML = `
        <div class="card-inner">
          ${cachedBadge}
          <img src="${thumb}" alt="${displayTitle}" loading="lazy">
          ${linkHtml}
          <p title="${title || '프로젝트 ' + (i+1)}">${displayTitle}</p>
        </div>
      `;
      grid.appendChild(d);
      
      // 프로젝트가 있으면 '프로젝트 없음' 메시지 숨기기
      $id('noProjects').style.display = 'none';
    }

    /* ── 프로젝트 저장 ── */
    function save(pages, title, isCached = false, pdfId = null) {
      const id = projects.push(pages) - 1;
      addCard(id, pages[0].thumb, title, isCached, pdfId);
    }

    /* ── 서버 PDF 로드 및 캐시 상태 확인 ── */
    async function loadServerPDFs() {
      try {
        // 로딩 표시 추가
        if (document.querySelectorAll('.card').length === 0) {
          showLoading("라이브러리 로딩 중...");
        }
        
        // 먼저 캐시 상태 확인
        const cacheStatusRes = await fetch('/api/cache-status');
        const cacheStatus = await cacheStatusRes.json();
        
        // PDF 프로젝트 목록 가져오기
        const response = await fetch('/api/pdf-projects');
        serverProjects = await response.json();
        
        // 기존 그리드 초기화
        grid.innerHTML = '';
        projects = [];
        
        if (serverProjects.length === 0) {
          hideLoading();
          $id('noProjects').style.display = 'block';
          return;
        }
        
        // 서버 PDF 로드 및 썸네일 생성 (병렬 처리로 최적화)
        const thumbnailPromises = serverProjects.map(async (project, index) => {
          updateLoading(`PDF 프로젝트 로딩 중... (${index+1}/${serverProjects.length})`);
          
          const pdfName = project.name;
          const isCached = cacheStatus[pdfName] && cacheStatus[pdfName].status === "completed";
          
          try {
            // 썸네일 가져오기
            const response = await fetch(`/api/pdf-thumbnail?path=${encodeURIComponent(project.path)}`);
            const data = await response.json();
            
            if(data.thumbnail) {
              const pages = [{
                src: data.thumbnail,
                thumb: data.thumbnail,
                path: project.path,
                cached: isCached
              }];
              
              return {
                pages,
                name: project.name,
                isCached,
                id: project.id
              };
            }
          } catch (err) {
            console.error(`썸네일 로드 오류 (${project.name}):`, err);
          }
          
          return null;
        });
        
        // 모든 썸네일 요청 기다리기
        const results = await Promise.all(thumbnailPromises);
        
        // 성공적으로 가져온 결과만 표시
        results.filter(result => result !== null).forEach(result => {
          save(result.pages, result.name, result.isCached, result.id);
        });
        
        hideLoading();
        
        // 프로젝트가 없을 경우 메시지 표시
        if (document.querySelectorAll('.card').length === 0) {
          $id('noProjects').style.display = 'block';
        }
      } catch(error) {
        console.error('서버 PDF 로드 실패:', error);
        hideLoading();
        showError("라이브러리 로딩 중 오류가 발생했습니다.");
      }
    }

    /* ── 캐시 상태 정기적으로 확인 ── */
    async function checkCacheStatus() {
      try {
        const response = await fetch('/api/cache-status');
        const cacheStatus = await response.json();
        
        // 현재 카드 상태 업데이트
        const cards = document.querySelectorAll('.card');
        
        for(let i = 0; i < cards.length; i++) {
          if(projects[i] && projects[i][0] && projects[i][0].path) {
            const pdfPath = projects[i][0].path;
            const pdfName = pdfPath.split('/').pop().replace('.pdf', '');
            
            // 캐시 상태 뱃지 업데이트
            let badgeEl = cards[i].querySelector('.cached-status');
            
            if(cacheStatus[pdfName] && cacheStatus[pdfName].status === "completed") {
              if(!badgeEl) {
                badgeEl = document.createElement('div');
                badgeEl.className = 'cached-status';
                badgeEl.textContent = '캐시됨';
                cards[i].querySelector('.card-inner')?.appendChild(badgeEl);
              } else if (badgeEl.textContent !== '캐시됨') {
                badgeEl.textContent = '캐시됨';
                badgeEl.style.background = 'var(--accent-color)';
              }
              projects[i][0].cached = true;
            } else if(cacheStatus[pdfName] && cacheStatus[pdfName].status === "processing") {
              if(!badgeEl) {
                badgeEl = document.createElement('div');
                badgeEl.className = 'cached-status';
                cards[i].querySelector('.card-inner')?.appendChild(badgeEl);
              }
              badgeEl.textContent = `${cacheStatus[pdfName].progress}%`;
              badgeEl.style.background = 'var(--secondary-color)';
            }
          }
        }
        
        // 현재 로딩 중인 PDF가 있으면 상태 확인
        if (currentLoadingPdfPath && pageLoadingInterval) {
          const pdfName = currentLoadingPdfPath.split('/').pop().replace('.pdf', '');
          
          if (cacheStatus[pdfName]) {
            const status = cacheStatus[pdfName].status;
            const progress = cacheStatus[pdfName].progress || 0;
            
            if (status === "completed") {
              // 캐싱 완료 시
              clearInterval(pageLoadingInterval);
              $id('loadingPages').style.display = 'none';
              currentLoadingPdfPath = null;
              
              // 완료된 캐시로 플립북 다시 로드
              refreshFlipBook();
            } else if (status === "processing") {
              // 진행 중일 때 표시 업데이트
              $id('loadingPages').style.display = 'block';
              $id('loadingPagesCount').textContent = `${progress}%`;
            }
          }
        }
        
      } catch(error) {
        console.error('캐시 상태 확인 오류:', error);
      }
    }

    /* ── PDF ID로 PDF 열기 ── */
    async function openPdfById(pdfId, pdfPath, isCached = false) {
      try {
        // 오디오 초기화 시도
        await initializeAudio().catch(e => console.warn('PDF 열기 전 오디오 초기화 실패:', e));
        
        // 먼저 홈 화면에서 카드를 찾아서 클릭하는 방법 시도
        let foundCard = false;
        const cards = document.querySelectorAll('.card');
        
        for (let i = 0; i < cards.length; i++) {
          if (cards[i].dataset.pdfId === pdfId) {
            cards[i].click();
            foundCard = true;
            break;
          }
        }
        
        // 카드를 찾지 못한 경우 직접 오픈
        if (!foundCard) {
          toggle(false);
          showLoading("PDF 준비 중...");
          
          let pages = [];
          
          // 이미 캐시된 경우 캐시된 데이터 사용
          if (isCached) {
            try {
              const response = await fetch(`/api/cached-pdf?path=${encodeURIComponent(pdfPath)}`);
              const cachedData = await response.json();
              
              if (cachedData.status === "completed" && cachedData.pages) {
                hideLoading();
                createFlipBook(cachedData.pages);
                // 현재 열린 PDF의 ID 저장
                currentPdfId = pdfId;
                // AI 버튼 표시
                $id('aiButton').style.display = 'block';
                return;
              }
            } catch (error) {
              console.error("캐시 데이터 로드 실패:", error);
            }
          }
          
          // 썸네일 가져오기
          try {
            const thumbResponse = await fetch(`/api/pdf-thumbnail?path=${encodeURIComponent(pdfPath)}`);
            const thumbData = await thumbResponse.json();
            
            if (thumbData.thumbnail) {
              pages = [{
                src: thumbData.thumbnail,
                thumb: thumbData.thumbnail,
                path: pdfPath,
                cached: isCached
              }];
            }
          } catch (error) {
            console.error("썸네일 로드 실패:", error);
          }
          
          // 일단 기본 페이지 추가
          if (pages.length === 0) {
            pages = [{
              path: pdfPath,
              cached: isCached
            }];
          }
          
          // 프로젝트에 추가하고 뷰어 실행
          const projectId = projects.push(pages) - 1;
          hideLoading();
          open(projectId);
          
          // 현재 열린 PDF의 ID 저장
          currentPdfId = pdfId;
          // AI 버튼 표시
          $id('aiButton').style.display = 'block';
        }
      } catch (error) {
        console.error("PDF ID로 열기 실패:", error);
        hideLoading();
        showError("PDF를 열 수 없습니다. 다시 시도해주세요.");
      }
    }

    /* ── 현재 PDF의 고유 URL 생성 및 복사 ── */
    function copyPdfShareUrl() {
      if (!currentPdfId) {
        showError("공유할 PDF가 없습니다.");
        return;
      }
      
      // 현재 도메인 기반 전체 URL 생성
      const shareUrl = `${window.location.origin}/view/${currentPdfId}`;
      
      // 클립보드에 복사
      navigator.clipboard.writeText(shareUrl)
        .then(() => {
          showMessage("PDF 링크가 복사되었습니다!");
        })
        .catch(err => {
          console.error("클립보드 복사 실패:", err);
          showError("링크 복사에 실패했습니다.");
        });
    }

    /* ── 카드 → FlipBook ── */
    async function open(i) {
      toggle(false);
      const pages = projects[i];
      
      // PDF ID 찾기 및 저장
      const card = document.querySelectorAll('.card')[i];
      if (card && card.dataset.pdfId) {
        currentPdfId = card.dataset.pdfId;
        // AI 버튼 표시
        $id('aiButton').style.display = 'block';
      } else {
        currentPdfId = null;
        // AI 버튼 숨김
        $id('aiButton').style.display = 'none';
      }
      
      // AI 챗봇 초기화
      toggleAiChat(false);
      hasLoadedSummary = false;
      $id('aiChatMessages').innerHTML = '';
      
      // 기존 FlipBook 정리
      if(fb) {
        fb.destroy();
        viewer.innerHTML = '';
      }
      
      // 서버 PDF 또는 로컬 프로젝트 처리
      if(pages[0].path) {
        const pdfPath = pages[0].path;
        
        // 점진적 로딩 플래그 초기화
        let progressiveLoading = false;
        currentLoadingPdfPath = pdfPath;
        
        // 캐시 여부 확인
        if(pages[0].cached) {
          // 캐시된 PDF 데이터 가져오기
          showLoading("캐시된 PDF 로딩 중...");
          
          try {
            const response = await fetch(`/api/cached-pdf?path=${encodeURIComponent(pdfPath)}`);
            const cachedData = await response.json();
            
            if(cachedData.status === "completed" && cachedData.pages) {
              hideLoading();
              createFlipBook(cachedData.pages);
              currentLoadingPdfPath = null;
              return;
            } else if(cachedData.status === "processing" && cachedData.pages && cachedData.pages.length > 0) {
              // 일부 페이지가 이미 처리된 경우 점진적 로딩 사용
              hideLoading();
              createFlipBook(cachedData.pages);
              progressiveLoading = true;
              
              // 점진적 로딩 중임을 표시
              startProgressiveLoadingIndicator(cachedData.progress, cachedData.total_pages);
            }
          } catch(error) {
            console.error("캐시 데이터 로드 오류:", error);
            // 캐시 로딩 실패 시 원본 PDF로 대체
          }
        }
        
        if (!progressiveLoading) {
          // 캐시가 없거나 로딩 실패 시 서버 PDF 로드
          showLoading("PDF 준비 중...");
          
          try {
            const response = await fetch(`/api/pdf-content?path=${encodeURIComponent(pdfPath)}`);
            const data = await response.json();
            
            // 캐시로 리다이렉트된 경우
            if(data.redirect) {
              const redirectRes = await fetch(data.redirect);
              const cachedData = await redirectRes.json();
              
              if(cachedData.status === "completed" && cachedData.pages) {
                hideLoading();
                createFlipBook(cachedData.pages);
                currentLoadingPdfPath = null;
                return;
              } else if(cachedData.status === "processing" && cachedData.pages && cachedData.pages.length > 0) {
                // 일부 페이지가 이미 처리된 경우 점진적 로딩 사용
                hideLoading();
                createFlipBook(cachedData.pages);
                
                // 점진적 로딩 중임을 표시
                startProgressiveLoadingIndicator(cachedData.progress, cachedData.total_pages);
                return;
              }
            }
            
            // 원본 PDF 로드 (ArrayBuffer 형태)
            const pdfResponse = await fetch(`/api/pdf-content?path=${encodeURIComponent(pdfPath)}`);
            
            // JSON 응답인 경우 (리다이렉트 등)
            try {
              const jsonData = await pdfResponse.clone().json();
              if (jsonData.redirect) {
                const redirectRes = await fetch(jsonData.redirect);
                const cachedData = await redirectRes.json();
                
                if(cachedData.pages && cachedData.pages.length > 0) {
                  hideLoading();
                  createFlipBook(cachedData.pages);
                  
                  if(cachedData.status === "processing") {
                    startProgressiveLoadingIndicator(cachedData.progress, cachedData.total_pages);
                  } else {
                    currentLoadingPdfPath = null;
                  }
                  return;
                }
              }
            } catch (e) {
              // JSON 파싱 실패 시 원본 PDF 데이터로 처리
            }
            
            // ArrayBuffer 형태의 PDF 데이터
            const pdfData = await pdfResponse.arrayBuffer();
            
            // PDF 로드 및 페이지 렌더링
            const pdf = await pdfjsLib.getDocument({data: pdfData}).promise;
            const pdfPages = [];
            
            for(let p = 1; p <= pdf.numPages; p++) {
              updateLoading(`페이지 준비 중... (${p}/${pdf.numPages})`);
              
              const pg = await pdf.getPage(p);
              const vp = pg.getViewport({scale: 1});
              const c = document.createElement('canvas');
              c.width = vp.width;
              c.height = vp.height;
              
              await pg.render({canvasContext: c.getContext('2d'), viewport: vp}).promise;
              pdfPages.push({src: c.toDataURL(), thumb: c.toDataURL()});
            }
            
            hideLoading();
            createFlipBook(pdfPages);
            currentLoadingPdfPath = null;
            
          } catch(error) {
            console.error('PDF 처리 중 오류 발생:', error);
            hideLoading();
            showError("PDF를 로드하는 중 오류가 발생했습니다.");
            currentLoadingPdfPath = null;
          }
        }
      } else {
        // 로컬 업로드된 프로젝트 실행
        createFlipBook(pages);
        currentLoadingPdfPath = null;
      }
    }

    /* ── 점진적 로딩 인디케이터 시작 ── */
    function startProgressiveLoadingIndicator(progress, totalPages) {
      // 진행 상태 표시 활성화
      $id('loadingPages').style.display = 'block';
      $id('loadingPagesCount').textContent = `${progress}%`;
      
      // 기존 인터벌 제거
      if (pageLoadingInterval) {
        clearInterval(pageLoadingInterval);
      }
      
      // 주기적으로 캐시 상태 확인 (2초마다)
      pageLoadingInterval = setInterval(async () => {
        if (!currentLoadingPdfPath) {
          clearInterval(pageLoadingInterval);
          $id('loadingPages').style.display = 'none';
          return;
        }
        
        try {
          const response = await fetch(`/api/cache-status?path=${encodeURIComponent(currentLoadingPdfPath)}`);
          const status = await response.json();
          
          // 상태 업데이트
          if (status.status === "completed") {
            clearInterval(pageLoadingInterval);
            $id('loadingPages').style.display = 'none';
            refreshFlipBook();  // 완료된 데이터로 새로고침
            currentLoadingPdfPath = null;
          } else if (status.status === "processing") {
            $id('loadingPagesCount').textContent = `${status.progress}%`;
          }
        } catch (e) {
          console.error("캐시 상태 확인 오류:", e);
        }
      }, 1000);
    }

    /* ── 플립북 새로고침 ── */
    async function refreshFlipBook() {
      if (!currentLoadingPdfPath || !fb) return;
      
      try {
        const response = await fetch(`/api/cached-pdf?path=${encodeURIComponent(currentLoadingPdfPath)}`);
        const cachedData = await response.json();
        
        if(cachedData.status === "completed" && cachedData.pages) {
          // 기존 플립북 정리
          fb.destroy();
          viewer.innerHTML = '';
          
          // 새 데이터로 재생성
          createFlipBook(cachedData.pages);
          currentLoadingPdfPath = null;
        }
      } catch (e) {
        console.error("플립북 새로고침 오류:", e);
      }
    }

    function createFlipBook(pages) {
      console.log('FlipBook 생성 시작. 페이지 수:', pages.length);
      
      try {
        // 화면 비율 계산
        const calculateAspectRatio = () => {
          const windowWidth = window.innerWidth;
          const windowHeight = window.innerHeight;
          const aspectRatio = windowWidth / windowHeight;
          
          // 너비 또는 높이 기준으로 최대 90% 제한
          let width, height;
          if (aspectRatio > 1) { // 가로 화면
            height = Math.min(windowHeight * 0.9, windowHeight - 40);
            width = height * aspectRatio * 0.8; // 가로 화면에서는 약간 줄임
            if (width > windowWidth * 0.9) {
              width = windowWidth * 0.9;
              height = width / (aspectRatio * 0.8);
            }
          } else { // 세로 화면
            width = Math.min(windowWidth * 0.9, windowWidth - 40);
            height = width / aspectRatio * 0.9; // 세로 화면에서는 약간 늘림
            if (height > windowHeight * 0.9) {
              height = windowHeight * 0.9;
              width = height * aspectRatio * 0.9;
            }
          }
          
          // 최적 사이즈 반환
          return {
            width: Math.round(width),
            height: Math.round(height)
          };
        };
        
        // 초기 화면 비율 계산
        const size = calculateAspectRatio();
        viewer.style.width = size.width + 'px';
        viewer.style.height = size.height + 'px';
        
        // 사운드 초기화 여부 확인
        if (!audioInitialized) {
          initializeAudio()
            .then(() => console.log('FlipBook 생성 전 오디오 초기화 완료'))
            .catch(e => console.warn('FlipBook 생성 시 오디오 초기화 실패:', e));
        }
        
        // 페이지 데이터 정제 (빈 페이지 처리)
        const validPages = pages.map(page => {
          // src가 없는 페이지는 로딩 중 이미지로 대체
          if (!page || !page.src) {
            return {
              src: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwIiBoZWlnaHQ9IjEwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSIjZjVmNWY1Ii8+PHRleHQgeD0iNTAlIiB5PSI1MCUiIGZvbnQtZmFtaWx5PSJBcmlhbCIgZm9udC1zaXplPSIxMiIgdGV4dC1hbmNob3I9Im1pZGRsZSIgZHk9Ii4zZW0iIGZpbGw9IiM1NTUiPkxvYWRpbmcuLi48L3RleHQ+PC9zdmc+',
              thumb: page && page.thumb ? page.thumb : ''
            };
          }
          return page;
        });
        
        fb = new FlipBook(viewer, {
          pages: validPages,
          viewMode: 'webgl',
          autoSize: true,
          flipDuration: 800,
          backgroundColor: '#fff',
          /* 🔊 내장 사운드 */
          sound: true,
          assets: {flipMp3: '/static/turnPage2.mp3', hardFlipMp3: '/static/turnPage2.mp3'}, // 절대 경로로 수정
          controlsProps: {
            enableFullscreen: true,
            enableToc: true,
            enableDownload: false,
            enablePrint: false,
            enableZoom: true,
            enableShare: true, // 공유 버튼 활성화
            enableSearch: true,
            enableAutoPlay: true,
            enableAnnotation: false,
            enableSound: true,
            enableLightbox: false,
            layout: 10, // 레이아웃 옵션
            skin: 'light', // 스킨 스타일
            autoNavigationTime: 3600, // 자동 넘김 시간(초)
            hideControls: false, // 컨트롤 숨김 비활성화
            paddingTop: 10, // 상단 패딩
            paddingLeft: 10, // 좌측 패딩
            paddingRight: 10, // 우측 패딩
            paddingBottom: 10, // 하단 패딩
            pageTextureSize: 1024, // 페이지 텍스처 크기
            thumbnails: true, // 섬네일 활성화
            autoHideControls: false, // 자동 숨김 비활성화
            controlsTimeout: 8000, // 컨트롤 표시 시간 연장
            shareHandler: copyPdfShareUrl // 공유 핸들러 설정
          }
        });
        
        // 화면 크기 변경 시 FlipBook 크기 조정
        window.addEventListener('resize', () => {
          if (fb) {
            const newSize = calculateAspectRatio();
            viewer.style.width = newSize.width + 'px';
            viewer.style.height = newSize.height + 'px';
            fb.resize();
          }
        });
        
        // FlipBook 생성 후 컨트롤바 강제 표시
        setTimeout(() => {
          try {
            // 컨트롤바 관련 요소 찾기 및 스타일 적용
            const menuBars = document.querySelectorAll('.flipbook-container .fb3d-menu-bar');
            if (menuBars && menuBars.length > 0) {
              menuBars.forEach(menuBar => {
                menuBar.style.display = 'block';
                menuBar.style.opacity = '1';
                menuBar.style.visibility = 'visible';
                menuBar.style.zIndex = '9999';
              });
            }
          } catch (e) {
            console.warn('컨트롤바 스타일 적용 중 오류:', e);
          }
        }, 1000);
        
        console.log('FlipBook 생성 완료');
      } catch (error) {
        console.error('FlipBook 생성 중 오류 발생:', error);
        showError("FlipBook을 생성하는 중 오류가 발생했습니다.");
      }
    }

    /* ── 네비게이션 ── */
    function toggle(showHome){
      $id('home').style.display=showHome?'block':'none';
      $id('viewerPage').style.display=showHome?'none':'block';
      $id('homeButton').style.display=showHome?'none':'block';
      $id('adminPage').style.display='none';
      
      // AI 버튼 관리
      $id('aiButton').style.display = (!showHome && currentPdfId) ? 'block' : 'none';
      
      // AI 챗봇이 열려있으면 닫기
      if (isAiChatActive) {
        toggleAiChat(false);
      }
      
      // 뷰어 모드일 때 스타일 변경
      if(!showHome) {
        document.body.classList.add('viewer-mode');
      } else {
        document.body.classList.remove('viewer-mode');
      }
    }
    
    /* -- 관리자 기능 -- */
    function setupAdminFunctions() {
      // 관리자 버튼 클릭 - 모달 표시
      const adminButton = document.getElementById('adminButton');
      const adminLoginModal = document.getElementById('adminLoginModal');
      const adminLoginClose = document.getElementById('adminLoginClose');
      const adminLoginButton = document.getElementById('adminLoginButton');
      const adminPasswordInput = document.getElementById('adminPasswordInput');
      const adminBackButton = document.getElementById('adminBackButton');
      
      if (adminButton) {
        adminButton.addEventListener('click', function() {
          if (adminLoginModal) {
            adminLoginModal.style.display = 'flex';
            if (adminPasswordInput) {
              adminPasswordInput.value = '';
              adminPasswordInput.focus();
            }
          }
        });
      }
      
      // 모달 닫기 버튼
      if (adminLoginClose) {
        adminLoginClose.addEventListener('click', function() {
          if (adminLoginModal) {
            adminLoginModal.style.display = 'none';
          }
        });
      }
      
      // 엔터 키로 로그인
      if (adminPasswordInput) {
        adminPasswordInput.addEventListener('keyup', function(e) {
          if (e.key === 'Enter' && adminLoginButton) {
            adminLoginButton.click();
          }
        });
      }
      
      // 로그인 버튼
      if (adminLoginButton) {
        adminLoginButton.addEventListener('click', async function() {
          if (!adminPasswordInput) return;
          
          const password = adminPasswordInput.value;
          
          try {
            showLoading("로그인 중...");
            
            const formData = new FormData();
            formData.append('password', password);
            
            const response = await fetch('/api/admin-login', {
              method: 'POST',
              body: formData
            });
            
            const data = await response.json();
            
            hideLoading();
            
            if (data.success) {
              // 로그인 성공 - 관리자 페이지 표시
              if (adminLoginModal) {
                adminLoginModal.style.display = 'none';
              }
              showAdminPage();
            } else {
              // 로그인 실패
              showError("관리자 인증 실패: 비밀번호가 일치하지 않습니다.");
            }
          } catch (error) {
            console.error("관리자 로그인 오류:", error);
            hideLoading();
            showError("로그인 처리 중 오류가 발생했습니다.");
          }
        });
      }
      
      // 관리자 페이지 뒤로가기
      if (adminBackButton) {
        adminBackButton.addEventListener('click', function() {
          document.getElementById('adminPage').style.display = 'none';
          document.getElementById('home').style.display = 'block';
        });
      }
    }
    
    // 관리자 페이지 표시
    async function showAdminPage() {
      showLoading("관리자 페이지 로딩 중...");
      
      // 다른 페이지 숨기기
      $id('home').style.display = 'none';
      $id('viewerPage').style.display = 'none';
      
      // 관리자 페이지의 PDF 목록 로드
      try {
        const response = await fetch('/api/permanent-pdf-projects');
        const data = await response.json();
        
        const adminGrid = $id('adminGrid');
        adminGrid.innerHTML = ''; // 기존 내용 지우기
        
        if (data.length === 0) {
          $id('noAdminProjects').style.display = 'block';
        } else {
          $id('noAdminProjects').style.display = 'none';
          
          // 각 PDF 파일에 대한 카드 생성
          const thumbnailPromises = data.map(async (pdf) => {
            try {
              // 썸네일 가져오기
              const thumbResponse = await fetch(`/api/pdf-thumbnail?path=${encodeURIComponent(pdf.path)}`);
              const thumbData = await thumbResponse.json();
              
              // 표시 여부 확인 (메인 페이지에 표시되는지)
              const mainPdfPath = pdf.path.split('/').pop();
              const isMainDisplayed = serverProjects.some(p => p.path.includes(mainPdfPath));
              
              // 관리자 카드 생성
              const card = document.createElement('div');
              card.className = 'admin-card card fade-in';
              
              // 고유 URL 생성
              const viewUrl = `${window.location.origin}/view/${pdf.id}`;
              
              // 썸네일 및 정보
              card.innerHTML = `
                <div class="card-inner">
                  ${pdf.cached ? '<div class="cached-status">캐시됨</div>' : ''}
                  <img src="${thumbData.thumbnail || ''}" alt="${pdf.name}" loading="lazy">
                  <p title="${pdf.name}">${pdf.name.length > 15 ? pdf.name.substring(0, 15) + '...' : pdf.name}</p>
                  <div style="position: absolute; bottom: 130px; left: 50%; transform: translateX(-50%); z-index:10;">
                    <a href="${viewUrl}" target="_blank" style="color:#4a6ee0; font-size:12px;">바로가기 링크</a>
                  </div>
                  ${isMainDisplayed ? 
                    `<button class="unfeature-btn" data-path="${pdf.path}">메인에서 제거</button>` : 
                    `<button class="feature-btn" data-path="${pdf.path}">메인에 표시</button>`}
                  <button class="delete-btn" data-path="${pdf.path}">삭제</button>
                </div>
              `;
              
              adminGrid.appendChild(card);
              
              // 삭제 버튼 이벤트
              const deleteBtn = card.querySelector('.delete-btn');
              if (deleteBtn) {
                deleteBtn.addEventListener('click', async function(e) {
                  e.stopPropagation(); // 카드 클릭 이벤트 전파 방지
                  
                  if (confirm(`정말 "${pdf.name}" PDF를 삭제하시겠습니까?`)) {
                    try {
                      showLoading("PDF 삭제 중...");
                      
                      const response = await fetch(`/api/admin/delete-pdf?path=${encodeURIComponent(pdf.path)}`, {
                        method: 'DELETE'
                      });
                      
                      const result = await response.json();
                      
                      hideLoading();
                      
                      if (result.success) {
                        card.remove();
                        showMessage("PDF가 성공적으로 삭제되었습니다.");
                        
                        // 메인 PDF 목록 새로고침
                        loadServerPDFs();
                      } else {
                        showError("삭제 실패: " + (result.message || "알 수 없는 오류"));
                      }
                    } catch (error) {
                      console.error("PDF 삭제 오류:", error);
                      hideLoading();
                      showError("PDF 삭제 중 오류가 발생했습니다.");
                    }
                  }
                });
              }
              
              // 메인에 표시 버튼 이벤트
              const featureBtn = card.querySelector('.feature-btn');
              if (featureBtn) {
                featureBtn.addEventListener('click', async function(e) {
                  e.stopPropagation(); // 카드 클릭 이벤트 전파 방지
                  
                  try {
                    showLoading("처리 중...");
                    
                    const response = await fetch(`/api/admin/feature-pdf?path=${encodeURIComponent(pdf.path)}`, {
                      method: 'POST'
                    });
                    
                    const result = await response.json();
                    
                    hideLoading();
                    
                    if (result.success) {
                      showMessage("PDF가 메인 페이지에 표시됩니다.");
                      // 관리자 페이지 새로고침
                      showAdminPage();
                      // 메인 PDF 목록 새로고침
                      loadServerPDFs();
                    } else {
                      showError("처리 실패: " + (result.message || "알 수 없는 오류"));
                    }
                  } catch (error) {
                    console.error("PDF 표시 설정 오류:", error);
                    hideLoading();
                    showError("처리 중 오류가 발생했습니다.");
                  }
                });
              }
              
              // 메인에서 제거 버튼 이벤트
              const unfeatureBtn = card.querySelector('.unfeature-btn');
              if (unfeatureBtn) {
                unfeatureBtn.addEventListener('click', async function(e) {
                  e.stopPropagation(); // 카드 클릭 이벤트 전파 방지
                  
                  try {
                    showLoading("처리 중...");
                    
                    const response = await fetch(`/api/admin/unfeature-pdf?path=${encodeURIComponent(pdf.path)}`, {
                      method: 'DELETE'
                    });
                    
                    const result = await response.json();
                    
                    hideLoading();
                    
                    if (result.success) {
                      showMessage("PDF가 메인 페이지에서 제거되었습니다.");
                      // 관리자 페이지 새로고침
                      showAdminPage();
                      // 메인 PDF 목록 새로고침
                      loadServerPDFs();
                    } else {
                      showError("처리 실패: " + (result.message || "알 수 없는 오류"));
                    }
                  } catch (error) {
                    console.error("PDF 표시 해제 오류:", error);
                    hideLoading();
                    showError("처리 중 오류가 발생했습니다.");
                  }
                });
              }
            } catch (error) {
              console.error(`PDF ${pdf.name} 처리 오류:`, error);
            }
          });
          
          await Promise.all(thumbnailPromises);
        }
        
        // 관리자 페이지 표시
        hideLoading();
        $id('adminPage').style.display = 'block';
        
      } catch (error) {
        console.error("관리자 페이지 로드 오류:", error);
        hideLoading();
        showError("관리자 페이지 로드 중 오류가 발생했습니다.");
        $id('home').style.display = 'block'; // 오류 시 홈으로 복귀
      }
    }

    /* -- 로딩 및 오류 표시 -- */
    function showLoading(message, progress = -1) {
      // 기존 로딩 컨테이너가 있다면 제거
      hideLoading();
      
      const loadingContainer = document.createElement('div');
      loadingContainer.className = 'loading-container fade-in';
      loadingContainer.id = 'loadingContainer';
      
      let progressBarHtml = '';
      if (progress >= 0) {
        progressBarHtml = `
          <div class="progress-bar-container">
            <div id="progressBar" class="progress-bar" style="width: ${progress}%;"></div>
          </div>
        `;
      }
      
      loadingContainer.innerHTML = `
        <div class="loading-spinner"></div>
        <p class="loading-text" id="loadingText">${message || '로딩 중...'}</p>
        ${progressBarHtml}
      `;
      
      document.body.appendChild(loadingContainer);
    }
    
    function updateLoading(message, progress = -1) {
      const loadingText = $id('loadingText');
      if (loadingText) {
        loadingText.textContent = message;
      }
      
      if (progress >= 0) {
        let progressBar = $id('progressBar');
        
        if (!progressBar) {
          const loadingContainer = $id('loadingContainer');
          if (loadingContainer) {
            const progressContainer = document.createElement('div');
            progressContainer.className = 'progress-bar-container';
            progressContainer.innerHTML = `<div id="progressBar" class="progress-bar" style="width: ${progress}%;"></div>`;
            loadingContainer.appendChild(progressContainer);
            progressBar = $id('progressBar');
          }
        } else {
          progressBar.style.width = `${progress}%`;
        }
      }
    }
    
    function hideLoading() {
      const loadingContainer = $id('loadingContainer');
      if (loadingContainer) {
        loadingContainer.remove();
      }
    }
    
    function showError(message) {
      // 기존 오류 메시지가 있다면 제거
      const existingError = $id('errorContainer');
      if (existingError) {
        existingError.remove();
      }
      
      const errorContainer = document.createElement('div');
      errorContainer.className = 'loading-container fade-in';
      errorContainer.id = 'errorContainer';
      errorContainer.innerHTML = `
        <p class="loading-text" style="color: #e74c3c;">${message}</p>
        <button id="errorCloseBtn" style="margin-top: 15px; padding: 8px 16px; background: #3498db; color: white; border: none; border-radius: 4px; cursor: pointer;">확인</button>
      `;
      
      document.body.appendChild(errorContainer);
      
      // 확인 버튼 클릭 이벤트
      $id('errorCloseBtn').onclick = () => {
        errorContainer.remove();
      };
      
      // 5초 후 자동으로 닫기
      setTimeout(() => {
        if ($id('errorContainer')) {
          $id('errorContainer').remove();
        }
      }, 5000);
    }
    
    function showMessage(message) {
      // 기존 메시지가 있다면 제거
      const existingMessage = $id('messageContainer');
      if (existingMessage) {
        existingMessage.remove();
      }
      
      const messageContainer = document.createElement('div');
      messageContainer.className = 'loading-container fade-in';
      messageContainer.id = 'messageContainer';
      messageContainer.innerHTML = `
        <p class="loading-text" style="color: #2ecc71;">${message}</p>
        <button id="messageCloseBtn" style="margin-top: 15px; padding: 8px 16px; background: #3498db; color: white; border: none; border-radius: 4px; cursor: pointer;">확인</button>
      `;
      
      document.body.appendChild(messageContainer);
      
      // 확인 버튼 클릭 이벤트
      $id('messageCloseBtn').onclick = () => {
        messageContainer.remove();
      };
      
      // 3초 후 자동으로 닫기
      setTimeout(() => {
        if ($id('messageContainer')) {
          $id('messageContainer').remove();
        }
      }, 3000);
    }
  </script>
</body>
</html>            
"""

if __name__ == "__main__":
    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 7860)))