app/app.py

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

import os
import json
import logging
import tempfile
import threading
import datetime
import time # 추가
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
)
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', '')

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 or '설정되지 않음 (프론트엔드에서 자동 설정)'}")

# 환경 변수가 없으면 기본값 설정
if not ADMIN_USERNAME:
    ADMIN_USERNAME = 'admin'
    logger.warning("ADMIN_USERNAME 환경변수가 없어 기본값 'admin'으로 설정합니다.")

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

# --- 로컬 모듈 임포트 ---
# MockComponent 정의 (임포트 실패 시 대체)
class MockComponent:
    def __init__(self):
        self.is_mock = True
    
    def search(self, query, top_k=5, first_stage_k=None):
        """빈 검색 결과를 반환합니다."""
        logger.warning(f"MockComponent.search 호출됨 (쿼리: {query[:30]}...)")
        return []
    
    def __getattr__(self, name):
        # Mock 객체의 어떤 속성이나 메소드 호출 시 경고 로그 출력 및 기본값 반환
        logger.warning(f"MockComponent에서 '{name}' 접근 시도됨 (실제 모듈 로드 실패)")
        # 메소드 호출 시에는 아무것도 안 하는 함수 반환
        if name in ['add_documents', 'save', 'transcribe_audio', 'rag_generate', 'set_llm', 'get_current_llm_details', 'prepare_rag_context', 'csv_to_documents', 'text_to_documents', 'load_documents_from_directory']:
            return lambda *args, **kwargs: logger.warning(f"Mocked method '{name}' called") or None
        # 속성 접근 시에는 None 반환
        return None

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
    MODULE_LOAD_SUCCESS = True
except ImportError as e:
    logger.error(f"로컬 모듈 임포트 실패: {e}. Mock 객체를 사용합니다.")
    VitoSTT = LLMInterface = DocumentProcessor = VectorRetriever = ReRanker = MockComponent
    # register_routes, register_device_routes는 임포트 실패 시 정의되지 않으므로 아래에서 처리
    MODULE_LOAD_SUCCESS = False
    # 임시로 빈 함수 정의 (앱 실행은 되도록)
    def register_routes(*args, **kwargs): logger.error("register_routes 임포트 실패")
    def register_device_routes(*args, **kwargs): logger.error("register_device_routes 임포트 실패")
# --- 로컬 모듈 임포트 끝 ---


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

# 세션 설정
app.secret_key = os.getenv('FLASK_SECRET_KEY', 'rag_chatbot_fixed_secret_key_12345')
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SESSION_COOKIE_HTTPONLY'] = True
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__))
# static 폴더 경로 수정 (app 폴더 내부의 static)
app.config['STATIC_FOLDER'] = os.path.join(APP_ROOT, 'static')
app.config['UPLOAD_FOLDER'] = os.path.join(APP_ROOT, 'uploads')
# data 및 index 경로는 app 폴더 외부로 설정 (프로젝트 루트 기준)
app.config['DATA_FOLDER'] = os.path.join(os.path.dirname(APP_ROOT), 'data')
app.config['INDEX_PATH'] = os.path.join(os.path.dirname(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'}

# --- 전역 객체 초기화 ---
llm_interface = None
stt_client = None
base_retriever = None
retriever = None
# app_ready 플래그 대신 threading.Event 사용
app_ready_event = threading.Event() # 초기 상태: False (set() 호출 전까지)

# --- 전역 객체 초기화 (try-except로 감싸기) ---
try:
    if MODULE_LOAD_SUCCESS: # 모듈 로드 성공 시에만 실제 초기화 시도
        llm_interface = LLMInterface(default_llm="openai")
        stt_client = VitoSTT()
    else: # 실패 시 Mock 객체 사용
        llm_interface = LLMInterface() # MockComponent
        stt_client = VitoSTT() # MockComponent
except Exception as e:
    logger.error(f"LLM 또는 STT 인터페이스 초기화 중 오류 발생: {e}", exc_info=True)
    llm_interface = MockComponent() # 오류 시 Mock 객체 할당
    stt_client = MockComponent() # 오류 시 Mock 객체 할당

# --- 인증 데코레이터 ---
def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        logger.info(f"----------- 인증 필요 페이지 접근 시도: {request.path} -----------")
        logger.debug(f"현재 플라스크 세션 객체: {session}") # DEBUG 레벨로 변경
        logger.info(f"현재 세션 상태: logged_in={session.get('logged_in', False)}, username={session.get('username', 'None')}")
        logger.debug(f"요청의 세션 쿠키 값: {request.cookies.get('session', 'None')}") # DEBUG 레벨로 변경

        if not session.get('logged_in'): # .get() 사용하는 것이 더 안전
            logger.warning(f"세션에 'logged_in' 없음 또는 False. 로그인 페이지로 리디렉션.")
            return redirect(url_for('login', next=request.url))

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


# --- 헬퍼 함수 (app_routes.py에도 있지만 여기서도 필요할 수 있음) ---
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
# --- 헬퍼 함수 끝 ---


# --- 검색기 초기화 관련 함수 ---
def init_retriever():
    """검색기 객체 초기화 또는 로드"""
    global base_retriever, retriever

    # 모듈 로드 실패 시 Mock 객체 반환
    if not MODULE_LOAD_SUCCESS:
        logger.warning("필수 모듈 로드 실패로 Mock 검색기 반환")
        base_retriever = VectorRetriever() # MockComponent
        retriever = ReRanker() # MockComponent
        return retriever

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

    # 1. 기본 검색기 로드 또는 초기화
    try:
        if os.path.exists(os.path.join(index_path, "documents.json")): # 저장 방식에 따라 확인 파일 변경 필요
            logger.info(f"인덱스 로드 시도: {index_path}")
            base_retriever = VectorRetriever.load(index_path)
            logger.info(f"인덱스 로드 성공. 문서 {len(getattr(base_retriever, 'documents', []))}개")
        else:
            logger.info("인덱스 파일 없음. 새 VectorRetriever 초기화 시도...")
            base_retriever = VectorRetriever()
            logger.info("새 VectorRetriever 초기화 성공.")
    except Exception as e:
        logger.error(f"기본 검색기 초기화/로드 실패: {e}", exc_info=True)
        base_retriever = MockComponent() # 실패 시 Mock 사용
        retriever = MockComponent()
        logger.info("Mock 검색기를 대체로 사용합니다.")
        return retriever # 초기화 실패해도 Mock 검색기 반환 (None 대신)

    # 2. 데이터 폴더 문서 로드 (기본 검색기가 비어있을 때)
    needs_loading = not hasattr(base_retriever, 'documents') or not getattr(base_retriever, 'documents', [])
    if needs_loading and os.path.exists(data_path):
        logger.info(f"기본 검색기가 비어있어 {data_path}에서 문서 로드 시도...")
        try:
            # DocumentProcessor.load_documents_from_directory 호출 확인
            if hasattr(DocumentProcessor, 'load_documents_from_directory'):
                docs = DocumentProcessor.load_documents_from_directory(
                    directory=data_path,
                    extensions=[".txt", ".md", ".csv"],
                    recursive=True
                )
                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)
            else:
                 logger.warning("DocumentProcessor에 load_documents_from_directory 메소드가 없습니다.")
        except Exception as e_load_add:
            logger.error(f"DATA_FOLDER 문서 로드/추가 중 오류: {e_load_add}", exc_info=True)

    # 3. 재순위화 검색기 초기화
    logger.info("재순위화 검색기 초기화 시도...")
    try:
        # custom_rerank_fn 정의
        def custom_rerank_fn(query, results):
            # 이 함수는 실제 재순위화 로직에 맞게 구현 필요
            # 예시: 단순히 score 기준으로 정렬
            results.sort(key=lambda x: x.get("score", 0) if isinstance(x, dict) else 0, reverse=True)
            return results

        # 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 retriever, base_retriever, llm_interface, stt_client, app_ready_event

    logger.info("백그라운드 초기화 시작...")
    start_init_time = time.time()

    try:
        # 1. LLM, STT 인터페이스 재확인 (이미 초기화 시도됨)
        if llm_interface is None or isinstance(llm_interface, MockComponent):
             logger.warning("LLM 인터페이스가 초기화되지 않았거나 Mock 객체입니다.")
             # 필요시 여기서 다시 초기화 시도 가능
        if stt_client is None or isinstance(stt_client, MockComponent):
             logger.warning("STT 클라이언트가 초기화되지 않았거나 Mock 객체입니다.")

        # 2. 검색기 초기화
        logger.info("검색기 초기화 시도 (background)...")
        retriever = init_retriever() # init_retriever가 base_retriever도 설정

        # 성공 여부 확인 - retriever가 None이 아니면 성공으로 간주
        if retriever is not None:
            if not isinstance(retriever, MockComponent):
                logger.info("검색기 초기화 성공 (background)")
            else:
                logger.warning("Mock 검색기를 사용합니다. 일부 기능이 제한될 수 있습니다.")
            # 중요: 검색기가 Mock 객체이더라도 app_ready_event.set()을 호출하여 로딩 상태를 종료합니다.
            app_ready_event.set()
            logger.info("app_ready_event가 True로 설정됨.")
        else:
            logger.error("검색기 초기화 실패 (background)")
            # 중요 수정: 실패 시에도 app_ready_event를 설정하여 로딩 페이지에서 벗어날 수 있도록 함
            # 이렇게 하면 앱 자체는 실행되어 사용 가능한 상태가 됨
            app_ready_event.set()
            logger.warning("검색기 초기화 실패했지만 app_ready_event를 True로 설정하여 앱을 사용 가능한 상태로 만듭니다.")

    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()
        # 중요 수정: 오류 발생 시에도 app_ready_event를 설정하여 로딩 페이지에서 벗어날 수 있도록 함
        app_ready_event.set()
        logger.warning("초기화 오류가 발생했지만 app_ready_event를 True로 설정하여 앱을 사용 가능한 상태로 만듭니다.")

    finally:
        end_init_time = time.time()
        logger.info(f"백그라운드 초기화 완료. 소요 시간: {end_init_time - start_init_time:.2f}초")
        logger.info(f"최종 앱 준비 상태 (app_ready_event.is_set()): {app_ready_event.is_set()}")

# 백그라운드 스레드 시작
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_event=app_ready_event,
        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:
    # 라우트 등록 실패는 심각한 문제이므로 Critical 레벨 사용 고려
    logger.critical(f"라우트 등록 중 치명적 오류 발생: {e}", exc_info=True)
    # 앱 실행을 중단하거나 최소한의 오류 페이지를 제공하는 로직 추가 가능

# --- 정적 파일 서빙 ---
# STATIC_FOLDER 설정을 사용하여 static 폴더 경로 지정
@app.route('/static/<path:path>')
def send_static(path):
    static_folder = app.config.get('STATIC_FOLDER', 'static') # 설정값 또는 기본값 사용
    # logger.debug(f"Serving static file: {path} from {static_folder}") # 디버깅 시 주석 해제
    return send_from_directory(static_folder, path)


# --- 요청 처리 훅 ---
@app.after_request
def after_request_func(response):
    """모든 응답에 대해 후처리 수행 (예: 보안 헤더 추가)"""
    # 예시: response.headers['X-Content-Type-Options'] = 'nosniff'
    return response

# 앱 실행 (로컬 테스트용)
if __name__ == '__main__':
    logger.info("Flask 앱을 직접 실행합니다 (개발용 서버).")
    # port 번호는 환경 변수 또는 기본값을 사용합니다.
    port = int(os.environ.get("PORT", 7860)) # 기본 포트 7860 사용
    logger.info(f"서버를 http://0.0.0.0:{port} 에서 시작합니다.")
    # debug=True는 개발 중에만 사용하고, 배포 시에는 False로 변경하거나 제거
    # use_reloader=False 추가하여 자동 리로드 비활성화 (백그라운드 스레드 문제 방지)
    app.run(debug=False, host='0.0.0.0', port=port, use_reloader=False)