app/app.py

"""
RAG 검색 챗봇 웹 애플리케이션 (세션 설정 수정 적용)
"""

import os
import json
import logging
import tempfile
import threading
import datetime
from flask import Flask, request, jsonify, render_template, send_from_directory, session, redirect, url_for
from werkzeug.utils import secure_filename
from dotenv import load_dotenv
from functools import wraps

# 로거 설정
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.DEBUG  # INFO에서 DEBUG로 변경하여 더 상세한 로그 확인
)
logger = logging.getLogger(__name__)

# 환경 변수 로드
load_dotenv()

# 환경 변수 로드 상태 확인 및 로깅
ADMIN_USERNAME = os.getenv('ADMIN_USERNAME')
ADMIN_PASSWORD = os.getenv('ADMIN_PASSWORD')
DEVICE_SERVER_URL = os.getenv('DEVICE_SERVER_URL', 'http://localhost:5050')

logger.info(f"==== 환경 변수 로드 상태 ====")
logger.info(f"ADMIN_USERNAME 설정 여부: {ADMIN_USERNAME is not None}")
# 비밀번호는 로드 여부만 기록 (보안)
logger.info(f"ADMIN_PASSWORD 설정 여부: {ADMIN_PASSWORD is not None}")
logger.info(f"DEVICE_SERVER_URL: {DEVICE_SERVER_URL}")

# 환경 변수가 없으면 기본값 설정 (개발용, 배포 시 환경 변수 설정 권장)
if not ADMIN_USERNAME:
    ADMIN_USERNAME = 'admin'
    logger.warning("ADMIN_USERNAME 환경변수가 없어 기본값 'admin'으로 설정합니다.")

if not ADMIN_PASSWORD:
    ADMIN_PASSWORD = 'rag12345'
    logger.warning("ADMIN_PASSWORD 환경변수가 없어 기본값 'rag12345'로 설정합니다.")
class MockComponent: pass

# --- 로컬 모듈 임포트 ---
# 실제 경로에 맞게 utils, retrieval 폴더가 존재해야 합니다.
try:
    from utils.vito_stt import VitoSTT
    from utils.llm_interface import LLMInterface
    from utils.document_processor import DocumentProcessor
    from retrieval.vector_retriever import VectorRetriever
    from retrieval.reranker import ReRanker
    # 라우트 정의 파일 임포트
    from app.app_routes import register_routes
    from app.app_device_routes import register_device_routes
except ImportError as e:
    logger.error(f"로컬 모듈 임포트 실패: {e}. utils 및 retrieval 패키지가 올바른 경로에 있는지 확인하세요.")
    # 개발/테스트를 위해 임시 클래스 정의 (실제 사용 시 제거)
    
    VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
# --- 로컬 모듈 임포트 끝 ---


# Flask 앱 초기화
app = Flask(__name__)

# 세션 설정 - 고정된 시크릿 키 사용 (실제 배포 시 환경 변수 등으로 관리 권장)
app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345') # 환경 변수 우선 사용

# --- 세션 쿠키 설정 수정 (허깅페이스 환경 고려) ---
# 허깅페이스 스페이스는 일반적으로 HTTPS로 서비스되므로 Secure=True 설정
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SESSION_COOKIE_HTTPONLY'] = True  # JavaScript에서 쿠키 접근 방지 (보안 강화)
# SameSite='Lax'가 대부분의 경우에 더 안전하고 호환성이 좋음.
# 만약 앱이 다른 도메인의 iframe 내에서 실행되어야 한다면 'None'으로 설정해야 함.
# (단, 'None'으로 설정 시 반드시 Secure=True여야 함)
# 로그 분석 결과 iframe 환경으로 확인되어 'None'으로 변경
app.config['SESSION_COOKIE_SAMESITE'] = 'None' # <--- 이렇게 변경합니다.
app.config['SESSION_COOKIE_DOMAIN'] = None  # 특정 도메인 제한 없음
app.config['SESSION_COOKIE_PATH'] = '/'  # 앱 전체 경로에 쿠키 적용
app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=1)  # 세션 유효 시간 증가
# --- 세션 쿠키 설정 끝 ---

# 최대 파일 크기 설정 (10MB)
app.config['MAX_CONTENT_LENGTH'] = 10 * 1024 * 1024
# 애플리케이션 파일 기준 상대 경로 설정
APP_ROOT = os.path.dirname(os.path.abspath(__file__))
app.config['UPLOAD_FOLDER'] = os.path.join(APP_ROOT, 'uploads')
app.config['DATA_FOLDER'] = os.path.join(APP_ROOT, '..', 'data')
app.config['INDEX_PATH'] = os.path.join(APP_ROOT, '..', 'data', 'index')

# 필요한 폴더 생성
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
os.makedirs(app.config['DATA_FOLDER'], exist_ok=True)
os.makedirs(app.config['INDEX_PATH'], exist_ok=True)

# 허용되는 오디오/문서 파일 확장자
ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}

# --- 전역 객체 초기화 ---
try:
    llm_interface = LLMInterface(default_llm="openai")
    stt_client = VitoSTT()
except NameError:
    logger.warning("LLM 또는 STT 인터페이스 초기화 실패. Mock 객체를 사용합니다.")
    llm_interface = MockComponent()
    stt_client = MockComponent()

base_retriever = None
retriever = None
app_ready = False # 앱 초기화 상태 플래그
# --- 전역 객체 초기화 끝 ---


# --- 인증 데코레이터 (수정됨) ---
def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        logger.info(f"----------- 인증 필요 페이지 접근 시도: {request.path} -----------")
        logger.info(f"현재 플라스크 세션 객체: {session}")
        logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
        # 브라우저가 보낸 실제 쿠키 확인 (디버깅용)
        logger.info(f"요청의 세션 쿠키 값: {request.cookies.get('session', 'None')}")

        # Flask 세션에 'logged_in' 키가 있는지 직접 확인
        if 'logged_in' not in session:
            logger.warning(f"플라스크 세션에 'logged_in' 없음. 로그인 페이지로 리디렉션.")
            # 수동 쿠키 확인 로직 제거됨
            return redirect(url_for('login', next=request.url)) # 로그인 후 원래 페이지로 돌아가도록 next 파라미터 추가

        logger.info(f"인증 성공: {session.get('username', 'unknown')} 사용자가 {request.path} 접근")
        return f(*args, **kwargs)
    return decorated_function
# --- 인증 데코레이터 끝 ---


# --- 헬퍼 함수 ---
def allowed_audio_file(filename):
    """파일이 허용된 오디오 확장자를 가지는지 확인"""
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS

def allowed_doc_file(filename):
    """파일이 허용된 문서 확장자를 가지는지 확인"""
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_DOC_EXTENSIONS
# --- 헬퍼 함수 끝 ---


# init_retriever 함수 내부에 로깅 추가 예시
# --- 검색기 초기화 관련 함수 ---
def init_retriever():
    """검색기 객체 초기화 또는 로드"""
    global base_retriever, retriever

    index_path = app.config['INDEX_PATH']
    data_path = app.config['DATA_FOLDER'] # data_path 정의 확인
    logger.info("--- init_retriever 시작 ---")

    # 1. 기본 검색기 로드 또는 초기화
    # ... (VectorRetriever 로드 또는 초기화 로직은 이전과 동일하게 유지) ...
    # VectorRetriever 초기화/로드 실패 시 base_retriever = None 및 return None 처리 포함
    if os.path.exists(os.path.join(index_path, "documents.json")):
        try:
            logger.info(f"인덱스 로드 시도: {index_path}")
            base_retriever = VectorRetriever.load(index_path)
            logger.info(f"인덱스 로드 성공. 문서 {len(getattr(base_retriever, 'documents', []))}개")
        except Exception as e:
            logger.error(f"인덱스 로드 실패: {e}", exc_info=True)
            logger.info("새 VectorRetriever 초기화 시도...")
            try:
                base_retriever = VectorRetriever()
                logger.info("새 VectorRetriever 초기화 성공.")
            except Exception as e_init:
                logger.error(f"새 VectorRetriever 초기화 실패: {e_init}", exc_info=True)
                base_retriever = None
    else:
        logger.info("인덱스 파일 없음. 새 VectorRetriever 초기화 시도...")
        try:
            base_retriever = VectorRetriever()
            logger.info("새 VectorRetriever 초기화 성공.")
        except Exception as e_init:
            logger.error(f"새 VectorRetriever 초기화 실패: {e_init}", exc_info=True)
            base_retriever = None

    if base_retriever is None:
        logger.error("base_retriever 초기화/로드에 실패하여 init_retriever 중단.")
        return None

    # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
    needs_loading = (not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', None)) # None 체크 추가
    if needs_loading and os.path.exists(data_path):
        logger.info(f"기본 검색기가 비어있어 {data_path}에서 문서 로드 시도...")
        try:
            # ================== 수정된 부분 1 시작 ==================
            # DocumentProcessor.load_documents_from_directory 호출 시 올바른 인자 전달
            docs = DocumentProcessor.load_documents_from_directory(
                directory=data_path, # <-- 경로 변수 사용
                extensions=[".txt", ".md", ".csv"], # <-- 필요한 확장자 전달
                recursive=True # <-- 재귀 탐색 여부 전달
            )
            # ================== 수정된 부분 1 끝 ====================
            logger.info(f"{len(docs)}개 문서 로드 성공.")
            if docs and hasattr(base_retriever, 'add_documents'):
                logger.info("검색기에 문서 추가 시도...")
                base_retriever.add_documents(docs)
                logger.info("문서 추가 완료.")

                if hasattr(base_retriever, 'save'):
                    logger.info(f"검색기 상태 저장 시도: {index_path}")
                    try:
                        base_retriever.save(index_path)
                        logger.info("인덱스 저장 완료.")
                    except Exception as e_save:
                        logger.error(f"인덱스 저장 실패: {e_save}", exc_info=True)
        except Exception as e_load_add:
            # load_documents_from_directory 자체에서 오류가 날 수도 있음 (권한 등)
            logger.error(f"DATA_FOLDER 문서 로드/추가 중 오류: {e_load_add}", exc_info=True)

    # 3. 재순위화 검색기 초기화
    logger.info("재순위화 검색기 초기화 시도...")
    try:
        # ================== 수정된 부분 2 시작 ==================
        # custom_rerank_fn 함수를 ReRanker 초기화 전에 정의
        def custom_rerank_fn(query, results):
            query_terms = set(query.lower().split())
            for result in results:
                if isinstance(result, dict) and "text" in result:
                    text = result["text"].lower()
                    term_freq = sum(1 for term in query_terms if term in text)
                    normalized_score = term_freq / (len(text.split()) + 1) * 10
                    result["rerank_score"] = result.get("score", 0) * 0.7 + normalized_score * 0.3
                elif isinstance(result, dict):
                        result["rerank_score"] = result.get("score", 0)
            results.sort(key=lambda x: x.get("rerank_score", 0) if isinstance(x, dict) else 0, reverse=True)
            return results
        # ================== 수정된 부분 2 끝 ====================

        # ReRanker 클래스 사용
        retriever = ReRanker(
            base_retriever=base_retriever,
            rerank_fn=custom_rerank_fn, # 이제 함수가 정의되었으므로 사용 가능
            rerank_field="text"
        )
        logger.info("재순위화 검색기 초기화 완료.")
    except Exception as e_rerank:
        logger.error(f"재순위화 검색기 초기화 실패: {e_rerank}", exc_info=True)
        logger.warning("재순위화 실패, 기본 검색기를 retriever로 사용합니다.")
        retriever = base_retriever # fallback

    logger.info("--- init_retriever 종료 ---")
    return retriever

def background_init():
    """백그라운드에서 검색기 초기화 수행"""
    global app_ready, retriever, base_retriever, llm_interface, stt_client

    temp_app_ready = False # 임시 상태 플래그
    try:
        logger.info("백그라운드 초기화 시작...")

        # 1. LLM, STT 인터페이스 초기화 (필요 시)
        if llm_interface is None or isinstance(llm_interface, MockComponent):
             if 'LLMInterface' in globals() and LLMInterface != MockComponent:
                 llm_interface = LLMInterface(default_llm="openai")
                 logger.info("LLM 인터페이스 초기화 완료.")
             else:
                 logger.warning("LLMInterface 클래스 없음. Mock 사용.")
                 llm_interface = MockComponent() # Mock 객체 보장
        if stt_client is None or isinstance(stt_client, MockComponent):
             if 'VitoSTT' in globals() and VitoSTT != MockComponent:
                 stt_client = VitoSTT()
                 logger.info("STT 클라이언트 초기화 완료.")
             else:
                 logger.warning("VitoSTT 클래스 없음. Mock 사용.")
                 stt_client = MockComponent() # Mock 객체 보장


        # 2. 검색기 초기화
        if 'VectorRetriever' in globals() and VectorRetriever != MockComponent:
            logger.info("실제 검색기 초기화 시도...")
            # init_retriever가 base_retriever와 retriever를 모두 설정한다고 가정
            retriever = init_retriever()
            # init_retriever 내부에서 base_retriever가 설정되지 않았다면 여기서 설정
            if hasattr(retriever, 'base_retriever') and base_retriever is None:
                 base_retriever = retriever.base_retriever
            elif base_retriever is None:
                 # retriever가 base_retriever를 포함하지 않는 경우 또는 ReRanker가 아닌 경우
                 # init_retriever에서 base_retriever를 직접 설정하도록 하거나, 여기서 별도 로직 필요
                 # 예시: base_retriever = VectorRetriever.load(...) 또는 VectorRetriever()
                 logger.warning("init_retriever 후 base_retriever가 설정되지 않음. 확인 필요.")
                 # 임시로 retriever 자체를 base_retriever로 설정 (동일 객체일 경우)
                 if isinstance(retriever, VectorRetriever):
                      base_retriever = retriever

            # 성공적으로 초기화 되었는지 확인 (None이 아닌지)
            if retriever is not None and base_retriever is not None:
                logger.info("검색기 (Retriever, Base Retriever) 초기화 성공")
                temp_app_ready = True # 초기화 성공 시에만 True 설정
            else:
                logger.error("검색기 초기화 후에도 retriever 또는 base_retriever가 None입니다.")
                # 실패 시 Mock 객체 할당 (최소한의 동작 보장)
                if base_retriever is None: base_retriever = MockComponent()
                if retriever is None: retriever = MockComponent()
                if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
                if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
                # temp_app_ready = False 또는 True (정책에 따라 결정)
                temp_app_ready = True # 일단 앱은 실행되도록 설정

        else:
            logger.warning("VectorRetriever 클래스 없음. Mock 검색기 사용.")
            base_retriever = MockComponent()
            retriever = MockComponent()
            if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
            if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
            temp_app_ready = True # Mock이라도 준비는 된 것으로 간주

        logger.info(f"백그라운드 초기화 완료. 최종 상태: {'Ready' if temp_app_ready else 'Not Ready (Error during init)'}")

    except Exception as e:
        logger.error(f"앱 백그라운드 초기화 중 심각한 오류 발생: {e}", exc_info=True)
        # 오류 발생 시에도 Mock 객체 할당 시도
        if base_retriever is None: base_retriever = MockComponent()
        if retriever is None: retriever = MockComponent()
        if not hasattr(retriever, 'search'): retriever.search = lambda query, **kwargs: []
        if not hasattr(base_retriever, 'documents'): base_retriever.documents = []
        temp_app_ready = True # 오류 발생해도 앱은 응답하도록 설정 (정책에 따라 False 가능)
        logger.warning("초기화 중 오류가 발생했지만 Mock 객체로 대체 후 앱 사용 가능 상태로 설정.")

    finally:
         # 최종적으로 app_ready 상태 업데이트
         app_ready = temp_app_ready

# 백그라운드 스레드 시작 부분은 그대로 유지
init_thread = threading.Thread(target=background_init)
init_thread.daemon = True
init_thread.start()

# 라우트 등록
try:
    # 기본 RAG 챗봇 라우트 등록
    register_routes(
        app=app, 
        login_required=login_required, 
        llm_interface=llm_interface, 
        retriever=retriever, 
        stt_client=stt_client, 
        DocumentProcessor=DocumentProcessor,
        base_retriever=base_retriever, 
        app_ready=app_ready,
        ADMIN_USERNAME=ADMIN_USERNAME,
        ADMIN_PASSWORD=ADMIN_PASSWORD,
        DEVICE_SERVER_URL=DEVICE_SERVER_URL
    )
    logger.info("기본 챗봇 라우트 등록 완료")
    
    # 장치 관리 라우트 등록
    register_device_routes(
        app=app,
        login_required=login_required,
        DEVICE_SERVER_URL=DEVICE_SERVER_URL
    )
    logger.info("장치 관리 라우트 등록 완료")
except Exception as e:
    logger.error(f"라우트 등록 중 오류 발생: {e}", exc_info=True)


# --- 정적 파일 서빙 ---
@app.route('/static/<path:path>')
def send_static(path):
    return send_from_directory('static', path)


# --- 요청 처리 훅 ---
@app.after_request
def after_request_func(response):
    """모든 응답에 대해 후처리 수행"""
    return response

# 앱 실행 (로컬 테스트용)
if __name__ == '__main__':
    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
    # 디버그 모드는 실제 배포 시 False로 설정해야 합니다.
    # port 번호는 환경 변수 또는 기본값을 사용합니다.
    port = int(os.environ.get("PORT", 7860))
    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
    app.run(debug=True, host='0.0.0.0', port=port)