app/app_routes.py

"""
RAG 검색 챗봇 웹 애플리케이션 - API 라우트 정의
"""

import os
import json
import logging
import tempfile
import requests
from flask import request, jsonify, render_template, send_from_directory, session, redirect, url_for
from datetime import datetime
from werkzeug.utils import secure_filename

# 로거 가져오기
logger = logging.getLogger(__name__)

def register_routes(app, login_required, llm_interface, retriever, stt_client, DocumentProcessor, base_retriever, app_ready, ADMIN_USERNAME, ADMIN_PASSWORD, DEVICE_SERVER_URL):
    """Flask 애플리케이션에 기본 라우트 등록"""
    
    # 헬퍼 함수
    def allowed_audio_file(filename):
        """파일이 허용된 오디오 확장자를 가지는지 확인"""
        ALLOWED_AUDIO_EXTENSIONS = {'mp3', 'wav', 'ogg', 'm4a'}
        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_AUDIO_EXTENSIONS

    def allowed_doc_file(filename):
        """파일이 허용된 문서 확장자를 가지는지 확인"""
        ALLOWED_DOC_EXTENSIONS = {'txt', 'md', 'pdf', 'docx', 'csv'}
        return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_DOC_EXTENSIONS

    @app.route('/login', methods=['GET', 'POST'])
    def login():
        error = None
        next_url = request.args.get('next')
        logger.info(f"-------------- 로그인 페이지 접속 (Next: {next_url}) --------------")
        logger.info(f"Method: {request.method}")

        if request.method == 'POST':
            logger.info("로그인 시도 받음")
            username = request.form.get('username', '')
            password = request.form.get('password', '')
            logger.info(f"입력된 사용자명: {username}")
            logger.info(f"비밀번호 입력 여부: {len(password) > 0}")

            # 환경 변수 또는 기본값과 비교
            valid_username = ADMIN_USERNAME
            valid_password = ADMIN_PASSWORD
            logger.info(f"검증용 사용자명: {valid_username}")
            logger.info(f"검증용 비밀번호 존재 여부: {valid_password is not None and len(valid_password) > 0}")

            if username == valid_username and password == valid_password:
                logger.info(f"로그인 성공: {username}")
                # 세션 설정 전 현재 세션 상태 로깅
                logger.debug(f"세션 설정 전: {session}")

                # 세션에 로그인 정보 저장
                session.permanent = True
                session['logged_in'] = True
                session['username'] = username
                session.modified = True

                logger.info(f"세션 설정 후: {session}")
                logger.info("세션 설정 완료, 리디렉션 시도")

                # 로그인 성공 후 리디렉션
                redirect_to = next_url or url_for('index')
                logger.info(f"리디렉션 대상: {redirect_to}")
                response = redirect(redirect_to)
                return response
            else:
                logger.warning("로그인 실패: 아이디 또는 비밀번호 불일치")
                if username != valid_username: logger.warning("사용자명 불일치")
                if password != valid_password: logger.warning("비밀번호 불일치")
                error = '아이디 또는 비밀번호가 올바르지 않습니다.'
        else:
            logger.info("로그인 페이지 GET 요청")
            if 'logged_in' in session:
                logger.info("이미 로그인된 사용자, 메인 페이지로 리디렉션")
                return redirect(url_for('index'))

        logger.info("---------- 로그인 페이지 렌더링 ----------")
        return render_template('login.html', error=error, next=next_url)


    @app.route('/logout')
    def logout():
        logger.info("-------------- 로그아웃 요청 --------------")
        logger.info(f"로그아웃 전 세션 상태: {session}")

        if 'logged_in' in session:
            username = session.get('username', 'unknown')
            logger.info(f"사용자 {username} 로그아웃 처리 시작")
            session.pop('logged_in', None)
            session.pop('username', None)
            session.modified = True
            logger.info(f"세션 정보 삭제 완료. 현재 세션: {session}")
        else:
            logger.warning("로그인되지 않은 상태에서 로그아웃 시도")

logger.info("로그인 페이지로 리디렉션")
        response = redirect(url_for('login'))
        return response


    @app.route('/')
    @login_required
    def index():
        """메인 페이지"""
        nonlocal app_ready
        
        # 앱 준비 상태 확인 - 30초 이상 지났으면 강제로 ready 상태로 변경
        current_time = datetime.now()
        start_time = datetime.fromtimestamp(os.path.getmtime(__file__))
        time_diff = (current_time - start_time).total_seconds()
        
        if not app_ready and time_diff > 30:
            logger.warning(f"앱이 30초 이상 초기화 중 상태입니다. 강제로 ready 상태로 변경합니다.")
            app_ready = True
        
        if not app_ready:
            logger.info("앱이 아직 준비되지 않아 로딩 페이지 표시")
            return render_template('loading.html'), 503  # 서비스 준비 안됨 상태 코드
        
        logger.info("메인 페이지 요청")
        return render_template('index.html')


    @app.route('/api/status')
    @login_required
    def app_status():
        """앱 초기화 상태 확인 API"""
        logger.info(f"앱 상태 확인 요청: {'Ready' if app_ready else 'Not Ready'}")
        return jsonify({"ready": app_ready})


    @app.route('/api/llm', methods=['GET', 'POST'])
    @login_required
    def llm_api():
        """사용 가능한 LLM 목록 및 선택 API"""
        if not app_ready:
            return jsonify({"error": "앱이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503

        if request.method == 'GET':
            logger.info("LLM 목록 요청")
            try:
                current_details = llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {"id": "unknown", "name": "Unknown"}
                supported_llms_dict = llm_interface.SUPPORTED_LLMS if hasattr(llm_interface, 'SUPPORTED_LLMS') else {}
                supported_list = [{
                    "name": name, "id": id, "current": id == current_details.get("id")
                } for name, id in supported_llms_dict.items()]

                return jsonify({
                    "supported_llms": supported_list,
                    "current_llm": current_details
                })
            except Exception as e:
                logger.error(f"LLM 정보 조회 오류: {e}")
                return jsonify({"error": "LLM 정보 조회 중 오류 발생"}), 500

        elif request.method == 'POST':
            data = request.get_json()
            if not data or 'llm_id' not in data:
                return jsonify({"error": "LLM ID가 제공되지 않았습니다."}), 400

            llm_id = data['llm_id']
            logger.info(f"LLM 변경 요청: {llm_id}")

            try:
                if not hasattr(llm_interface, 'set_llm') or not hasattr(llm_interface, 'llm_clients'):
                    raise NotImplementedError("LLM 인터페이스에 필요한 메소드/속성 없음")

                if llm_id not in llm_interface.llm_clients:
                    return jsonify({"error": f"지원되지 않는 LLM ID: {llm_id}"}), 400

                success = llm_interface.set_llm(llm_id)
                if success:
                    new_details = llm_interface.get_current_llm_details()
                    logger.info(f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.")
                    return jsonify({
                        "success": True,
                        "message": f"LLM이 '{new_details.get('name', llm_id)}'로 변경되었습니다.",
                        "current_llm": new_details
                    })
                else:
                    logger.error(f"LLM 변경 실패 (ID: {llm_id})")
                    return jsonify({"error": "LLM 변경 중 내부 오류 발생"}), 500
            except Exception as e:
                logger.error(f"LLM 변경 처리 중 오류: {e}", exc_info=True)
                return jsonify({"error": f"LLM 변경 중 오류 발생: {str(e)}"}), 500


    @app.route('/api/chat', methods=['POST'])
    @login_required
    def chat():
        """텍스트 기반 챗봇 API"""
        if not app_ready or retriever is None:
            return jsonify({"error": "앱/검색기가 아직 초기화 중입니다. 잠시 후 다시 시도해주세요."}), 503

        try:
            data = request.get_json()
            if not data or 'query' not in data:
                return jsonify({"error": "쿼리가 제공되지 않았습니다."}), 400

            query = data['query']
            logger.info(f"텍스트 쿼리 수신: {query[:100]}...")

            # RAG 검색 수행
            if not hasattr(retriever, 'search'):
                raise NotImplementedError("Retriever에 search 메소드가 없습니다.")
            search_results = retriever.search(query, top_k=5, first_stage_k=6)

            # 컨텍스트 준비
            if not hasattr(DocumentProcessor, 'prepare_rag_context'):
                raise NotImplementedError("DocumentProcessor에 prepare_rag_context 메소드가 없습니다.")
            context = DocumentProcessor.prepare_rag_context(search_results, field="text")

            if not context:
                logger.warning("검색 결과가 없어 컨텍스트를 생성하지 못함.")

            # LLM에 질의
            llm_id = data.get('llm_id', None)
            if not hasattr(llm_interface, 'rag_generate'):
                raise NotImplementedError("LLMInterface에 rag_generate 메소드가 없습니다.")

            if not context:
                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
                logger.info("컨텍스트 없이 기본 응답 생성")
            else:
                answer = llm_interface.rag_generate(query, context, llm_id=llm_id)
                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")

            # 소스 정보 추출 (CSV ID 추출 로직 포함)
            sources = []
            if search_results:
                for result in search_results:
                    if not isinstance(result, dict):
                        logger.warning(f"예상치 못한 검색 결과 형식: {type(result)}")
                        continue

                    if "source" in result:
                        source_info = {
                            "source": result.get("source", "Unknown"),
                            "score": result.get("rerank_score", result.get("score", 0))
                        }

                        # CSV 파일 특정 처리
                        if "text" in result and result.get("filetype") == "csv":
                            try:
                                text_lines = result["text"].strip().split('\n')
                                if text_lines:
                                    first_line = text_lines[0].strip()
                                    if ',' in first_line:
                                        first_column = first_line.split(',')[0].strip()
                                        source_info["id"] = first_column
                                        logger.debug(f"CSV 소스 ID 추출: {first_column} from {source_info['source']}")
                            except Exception as e:
                                logger.warning(f"CSV 소스 ID 추출 실패 ({result.get('source')}): {e}")

                        sources.append(source_info)

            # 최종 응답
            response_data = {
                "answer": answer,
                "sources": sources,
                "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
            }
            return jsonify(response_data)

        except Exception as e:
            logger.error(f"채팅 처리 중 오류 발생: {e}", exc_info=True)
            return jsonify({"error": f"처리 중 오류가 발생했습니다: {str(e)}"}), 500


    @app.route('/api/voice', methods=['POST'])
    @login_required
    def voice_chat():
        """음성 챗 API 엔드포인트"""
        if not app_ready:
            logger.warning("앱 초기화가 완료되지 않았지만 음성 API 요청 처리 시도")
            # 여기서 바로 리턴하지 않고 계속 진행
            # 사전 검사: retriever와 stt_client가 제대로 초기화되었는지 확인

        if retriever is None:
            logger.error("retriever가 아직 초기화되지 않았습니다")
            return jsonify({
                "transcription": "(음성을 텍스트로 변환했지만 검색 엔진이 아직 준비되지 않았습니다)",
                "answer": "죄송합니다. 검색 엔진이 아직 초기화 중입니다. 잠시 후 다시 시도해주세요.",
                "sources": []
            })
        # 또는 필수 컴포넌트가 없을 때만 특별 응답 반환
        if stt_client is None:
            return jsonify({
                "transcription": "(음성 인식 기능이 준비 중입니다)",
                "answer": "죄송합니다. 현재 음성 인식 서비스가 초기화 중입니다. 잠시 후 다시 시도해주세요.",
                "sources": []
            })

        logger.info("음성 챗 요청 수신")
        
        if 'audio' not in request.files:
            logger.error("오디오 파일이 제공되지 않음")
            return jsonify({"error": "오디오 파일이 제공되지 않았습니다."}), 400

        audio_file = request.files['audio']
        logger.info(f"수신된 오디오 파일: {audio_file.filename} ({audio_file.content_type})")

        try:
            # 오디오 파일 처리
            # 임시 파일 사용 고려 (메모리 부담 줄이기 위해)
            with tempfile.NamedTemporaryFile(delete=True) as temp_audio:
                audio_file.save(temp_audio.name)
                logger.info(f"오디오 파일을 임시 저장: {temp_audio.name}")
                # VitoSTT.transcribe_audio 가 파일 경로 또는 바이트를 받을 수 있도록 구현되어야 함
                # 여기서는 파일 경로를 사용한다고 가정
                if not hasattr(stt_client, 'transcribe_audio'):
                    raise NotImplementedError("STT 클라이언트에 transcribe_audio 메소드가 없습니다.")

                # 파일 경로로 전달 시
                # stt_result = stt_client.transcribe_audio(temp_audio.name, language="ko")
                # 바이트로 전달 시
                with open(temp_audio.name, 'rb') as f_bytes:
                    audio_bytes = f_bytes.read()
                stt_result = stt_client.transcribe_audio(audio_bytes, language="ko")


            if not isinstance(stt_result, dict) or not stt_result.get("success"):
                error_msg = stt_result.get("error", "알 수 없는 STT 오류") if isinstance(stt_result, dict) else "STT 결과 형식 오류"
                logger.error(f"음성인식 실패: {error_msg}")
                return jsonify({
                    "error": "음성인식 실패",
                    "details": error_msg
                }), 500

            transcription = stt_result.get("text", "")
            if not transcription:
                logger.warning("음성인식 결과가 비어있습니다.")
                return jsonify({"error": "음성에서 텍스트를 인식하지 못했습니다.", "transcription": ""}), 400

            logger.info(f"음성인식 성공: {transcription[:50]}...")
            if retriever is None:
                logger.error("STT 성공 후 검색 시도 중 retriever가 None임")
                return jsonify({
                    "transcription": transcription,
                    "answer": "음성을 인식했지만, 현재 검색 시스템이 준비되지 않았습니다. 잠시 후 다시 시도해주세요.",
                    "sources": []
                })
            # --- 이후 로직은 /api/chat과 거의 동일 ---
            # RAG 검색 수행
            search_results = retriever.search(transcription, top_k=5, first_stage_k=6)
            context = DocumentProcessor.prepare_rag_context(search_results, field="text")

            if not context:
                logger.warning("음성 쿼리에 대한 검색 결과 없음.")
                # answer = "죄송합니다. 관련 정보를 찾을 수 없습니다." (아래 LLM 호출 로직에서 처리)
                pass

            # LLM 호출
            llm_id = request.form.get('llm_id', None) # 음성 요청은 form 데이터로 LLM ID 받을 수 있음
            if not context:
                answer = "죄송합니다. 관련 정보를 찾을 수 없습니다."
                logger.info("컨텍스트 없이 기본 응답 생성")
            else:
                answer = llm_interface.rag_generate(transcription, context, llm_id=llm_id)
                logger.info(f"LLM 응답 생성 완료 (길이: {len(answer)})")


            # 소스 정보 추출
            enhanced_sources = []
            if search_results:
                for doc in search_results:
                    if not isinstance(doc, dict): continue # A
                    if "source" in doc:
                        source_info = {
                            "source": doc.get("source", "Unknown"),
                            "score": doc.get("rerank_score", doc.get("score", 0))
                        }
                        if "text" in doc and doc.get("filetype") == "csv":
                            try:
                                text_lines = doc["text"].strip().split('\n')
                                if text_lines:
                                    first_line = text_lines[0].strip()
                                    if ',' in first_line:
                                        first_column = first_line.split(',')[0].strip()
                                        source_info["id"] = first_column
                            except Exception as e:
                                logger.warning(f"[음성챗] CSV 소스 ID 추출 실패 ({doc.get('source')}): {e}")
                        enhanced_sources.append(source_info)

            # 최종 응답
            response_data = {
                "transcription": transcription,
                "answer": answer,
                "sources": enhanced_sources,
                "llm": llm_interface.get_current_llm_details() if hasattr(llm_interface, 'get_current_llm_details') else {}
            }
            return jsonify(response_data)

        except Exception as e:
            logger.error(f"음성 챗 처리 중 오류 발생: {e}", exc_info=True)
            return jsonify({
                "error": "음성 처리 중 내부 오류 발생",
                "details": str(e)
            }), 500


    @app.route('/api/upload', methods=['POST'])
    @login_required
    def upload_document():
        """지식베이스 문서 업로드 API"""
        if not app_ready or base_retriever is None:
            return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503

        if 'document' not in request.files:
            return jsonify({"error": "문서 파일이 제공되지 않았습니다."}), 400

        doc_file = request.files['document']
        if doc_file.filename == '':
            return jsonify({"error": "선택된 파일이 없습니다."}), 400

        if not allowed_doc_file(doc_file.filename):
            logger.error(f"허용되지 않는 파일 형식: {doc_file.filename}")
            return jsonify({"error": f"허용되지 않는 파일 형식입니다. 허용: {', '.join(ALLOWED_DOC_EXTENSIONS)}"}), 400

        try:
            filename = secure_filename(doc_file.filename)
            filepath = os.path.join(app.config['DATA_FOLDER'], filename)
            doc_file.save(filepath)
            logger.info(f"문서 저장 완료: {filepath}")

            # 문서 처리 (인코딩 처리 포함)
            try:
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()
            except UnicodeDecodeError:
                logger.info(f"UTF-8 디코딩 실패, CP949로 시도: {filename}")
                try:
                    with open(filepath, 'r', encoding='cp949') as f:
                        content = f.read()
                except Exception as e_cp949:
                    logger.error(f"CP949 디코딩 실패 ({filename}): {e_cp949}")
                    return jsonify({"error": "파일 인코딩을 읽을 수 없습니다 (UTF-8, CP949 시도 실패)."}), 400
            except Exception as e_read:
                logger.error(f"파일 읽기 오류 ({filename}): {e_read}")
                return jsonify({"error": f"파일 읽기 중 오류 발생: {str(e_read)}"}), 500


            # 메타데이터 및 문서 분할/처리
            metadata = {
                "source": filename, "filename": filename,
                "filetype": filename.rsplit('.', 1)[1].lower(),
                "filepath": filepath
            }
            file_ext = metadata["filetype"]
            docs = []

            if not hasattr(DocumentProcessor, 'csv_to_documents') or not hasattr(DocumentProcessor, 'text_to_documents'):
                raise NotImplementedError("DocumentProcessor에 필요한 메소드 없음")

            if file_ext == 'csv':
                logger.info(f"CSV 파일 처리 시작: {filename}")
                docs = DocumentProcessor.csv_to_documents(content, metadata) # 행 단위 처리 가정
            else: # 기타 텍스트 기반 문서
                logger.info(f"일반 텍스트 문서 처리 시작: {filename}")
                # PDF, DOCX 등은 별도 라이브러리(pypdf, python-docx) 필요
                if file_ext in ['pdf', 'docx']:
                    logger.warning(f".{file_ext} 파일 처리는 현재 구현되지 않았습니다. 텍스트 추출 로직 추가 필요.")
                    # 여기에 pdf/docx 텍스트 추출 로직 추가
                    # 예: content = extract_text_from_pdf(filepath)
                    # content = extract_text_from_docx(filepath)
                    # 임시로 비워둠
                    content = ""

                if content: # 텍스트 내용이 있을 때만 처리
                    docs = DocumentProcessor.text_to_documents(
                        content, metadata=metadata,
                        chunk_size=512, chunk_overlap=50
                    )

            # 검색기에 문서 추가 및 인덱스 저장
            if docs:
                if not hasattr(base_retriever, 'add_documents') or not hasattr(base_retriever, 'save'):
                    raise NotImplementedError("기본 검색기에 add_documents 또는 save 메소드 없음")

                logger.info(f"{len(docs)}개 문서 청크를 검색기에 추가합니다...")
                base_retriever.add_documents(docs)

                # 인덱스 저장 (업로드마다 저장 - 비효율적일 수 있음)
                logger.info(f"검색기 상태를 저장합니다...")
                index_path = app.config['INDEX_PATH']
                try:
                    base_retriever.save(index_path)
                    logger.info("인덱스 저장 완료")
                    # 재순위화 검색기도 업데이트 필요 시 로직 추가
                    # 예: retriever.update_base_retriever(base_retriever)
                    return jsonify({
                        "success": True,
                        "message": f"파일 '{filename}' 업로드 및 처리 완료 ({len(docs)}개 청크 추가)."
                    })
                except Exception as e_save:
                    logger.error(f"인덱스 저장 중 오류 발생: {e_save}")
                    return jsonify({"error": f"인덱스 저장 중 오류: {str(e_save)}"}), 500
            else:
                logger.warning(f"파일 '{filename}'에서 처리할 내용이 없거나 지원되지 않는 형식입니다.")
                # 파일은 저장되었으므로 성공으로 간주할지 결정 필요
                return jsonify({
                    "warning": True,
                    "message": f"파일 '{filename}'이 저장되었지만 처리할 내용이 없습니다."
                })

        except Exception as e:
            logger.error(f"파일 업로드 또는 처리 중 오류 발생: {e}", exc_info=True)
            return jsonify({"error": f"파일 업로드 중 오류: {str(e)}"}), 500


    @app.route('/api/documents', methods=['GET'])
    @login_required
    def list_documents():
        """지식베이스 문서 목록 API"""
        if not app_ready or base_retriever is None:
            return jsonify({"error": "앱/기본 검색기가 아직 초기화 중입니다."}), 503

        try:
            sources = {}
            total_chunks = 0
            # base_retriever.documents 와 같은 속성이 실제 클래스에 있다고 가정
            if hasattr(base_retriever, 'documents') and base_retriever.documents:
                logger.info(f"총 {len(base_retriever.documents)}개 문서 청크에서 소스 목록 생성 중...")
                for doc in base_retriever.documents:
                    # 문서 청크가 딕셔너리 형태라고 가정
                    if not isinstance(doc, dict): continue

                    source = doc.get("source", "unknown") # 메타데이터에서 source 가져오기
                    if source == "unknown" and "metadata" in doc and isinstance(doc["metadata"], dict):
                        source = doc["metadata"].get("source", "unknown") # Langchain Document 구조 고려

                    if source != "unknown":
                        if source in sources:
                            sources[source]["chunks"] += 1
                        else:
                            # 메타데이터에서 추가 정보 가져오기
                            filename = doc.get("filename", source)
                            filetype = doc.get("filetype", "unknown")
                            if "metadata" in doc and isinstance(doc["metadata"], dict):
                                filename = doc["metadata"].get("filename", filename)
                                filetype = doc["metadata"].get("filetype", filetype)

                            sources[source] = {
                                "filename": filename,
                                "chunks": 1,
                                "filetype": filetype
                            }
                    total_chunks += 1
            else:
                logger.info("검색기에 문서가 없거나 documents 속성을 찾을 수 없습니다.")

            # 목록 형식 변환 및 정렬
            documents = [{"source": src, **info} for src, info in sources.items()]
            documents.sort(key=lambda x: x["chunks"], reverse=True)

            logger.info(f"문서 목록 조회 완료: {len(documents)}개 소스 파일, {total_chunks}개 청크")
            return jsonify({
                "documents": documents,
                "total_documents": len(documents),
                "total_chunks": total_chunks
            })

        except Exception as e:
            logger.error(f"문서 목록 조회 중 오류 발생: {e}", exc_info=True)
            return jsonify({"error": f"문서 목록 조회 중 오류: {str(e)}"}), 500