app/__init__.py

"""
Flask 애플리케이션 초기화
"""

from flask import Flask, request, send_from_directory, jsonify
from flask_login import LoginManager
import sqlite3
from pathlib import Path
from typing import Optional

from app.database import db, User
from app.core.config import Config, get_config
from app.core.logger import get_logger

logger = get_logger(__name__)

login_manager = LoginManager()
login_manager.login_view = 'main.login'
login_manager.login_message = '로그인이 필요합니다.'
login_manager.login_message_category = 'info'

@login_manager.unauthorized_handler
def unauthorized():
    """인증되지 않은 사용자 처리"""
    from flask import redirect, url_for, request
    # API 요청인 경우 JSON 응답
    if request.path.startswith('/api/'):
        from flask import jsonify
        return jsonify({'error': '로그인이 필요합니다.'}), 401
    # 일반 요청인 경우 로그인 페이지로 리다이렉트
    return redirect(url_for('main.login', next=request.path))


@login_manager.user_loader
def load_user(user_id: str) -> Optional[User]:
    """
    사용자 로드 함수 (Flask-Login용)
    
    Args:
        user_id: 사용자 ID (문자열)
    
    Returns:
        User 객체 또는 None
    """
    try:
        return User.query.get(int(user_id))
    except (ValueError, TypeError):
        return None


def create_app() -> Flask:
    """
    Flask 애플리케이션 팩토리 함수
    
    Returns:
        설정된 Flask 애플리케이션 인스턴스
    """
    config = get_config()
    
    # 필수 디렉토리 생성
    config.ensure_directories()
    
    # 템플릿 폴더 및 static 폴더 경로 설정
    template_folder = str(config.TEMPLATES_FOLDER)
    static_folder = str(config.STATIC_FOLDER)
    
    app = Flask(__name__, template_folder=template_folder, static_folder=static_folder)
    
    # Flask 설정 적용
    app.config['SECRET_KEY'] = config.SECRET_KEY
    app.config['SQLALCHEMY_DATABASE_URI'] = config.SQLALCHEMY_DATABASE_URI
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = config.SQLALCHEMY_TRACK_MODIFICATIONS
    app.config['MAX_CONTENT_LENGTH'] = config.MAX_CONTENT_LENGTH
    
    # 확장 초기화
    db.init_app(app)
    login_manager.init_app(app)
    
    # Blueprint 등록
    from app.routes import main_bp
    app.register_blueprint(main_bp)
    
    # favicon.ico 핸들러 추가
    @app.route('/favicon.ico')
    def favicon():
        """favicon.ico 요청 처리"""
        try:
            return send_from_directory(
                str(config.STATIC_FOLDER),
                'logo.webp',
                mimetype='image/webp'
            )
        except Exception as e:
            logger.warning(f"favicon.ico 처리 실패: {e}")
            return '', 204  # No Content
    
    # 404 에러 핸들러 (실제로 존재하지 않는 라우트에만 적용)
    @app.errorhandler(404)
    def not_found(error):
        """404 에러 처리"""
        logger.warning(f"404 에러: {request.path} - {request.method}")
        # API 요청인 경우 JSON 응답
        if request.path.startswith('/api/'):
            return jsonify({'error': '리소스를 찾을 수 없습니다.', 'path': request.path}), 404
        # 정적 파일 요청인 경우 404 반환
        if request.path.startswith('/static/'):
            return '', 404
        # 로그인 페이지는 404가 아닌 정상 라우트이므로 리다이렉트하지 않음
        # Flask-Login이 자동으로 처리하도록 함
        return jsonify({'error': '페이지를 찾을 수 없습니다.', 'path': request.path}), 404
    
    # 요청 로깅 미들웨어 추가
    @app.before_request
    def log_request_info():
        """각 HTTP 요청 정보를 로깅"""
        logger.info(f"[요청] {request.method} {request.path} - IP: {request.remote_addr}")
        if request.args:
            logger.debug(f"[요청 파라미터] {dict(request.args)}")
    
    @app.after_request
    def log_response_info(response):
        """각 HTTP 응답 정보를 로깅"""
        logger.info(f"[응답] {request.method} {request.path} - 상태: {response.status_code}")
        
        # Permissions-Policy 헤더 추가 (iframe 임베드 시 경고 방지)
        # Hugging Face Spaces에서 iframe으로 임베드될 때 발생하는 경고를 방지
        permissions_policy = (
            "ambient-light-sensor=(), "
            "battery=(), "
            "document-domain=(), "
            "layout-animations=(), "
            "legacy-image-formats=(), "
            "oversized-images=(), "
            "vr=(), "
            "wake-lock=()"
        )
        response.headers['Permissions-Policy'] = permissions_policy
        
        return response
    
    # 데이터베이스 초기화 및 마이그레이션
    with app.app_context():
        db.create_all()
        migrate_database(app)
        create_admin_user()
    
    logger.info("Flask 애플리케이션이 초기화되었습니다.")
    
    return app


def migrate_database(app: Flask) -> None:
    """
    데이터베이스 마이그레이션 실행
    
    Args:
        app: Flask 애플리케이션 인스턴스
    """
    try:
        db_uri = app.config['SQLALCHEMY_DATABASE_URI']
        
        if not db_uri.startswith('sqlite:///'):
            logger.warning(f"SQLite가 아닌 데이터베이스는 자동 마이그레이션이 지원되지 않습니다: {db_uri}")
            return
        
        db_path_str = db_uri.replace('sqlite:///', '')
        db_path = Path(db_path_str)
        
        # 상대 경로인 경우 instance 폴더 기준으로 처리
        if not db_path.is_absolute():
            db_path = Path(app.instance_path) / db_path
        
        if not db_path.exists():
            logger.info(f"데이터베이스 파일이 없습니다 (새로 생성됨): {db_path}")
            return
        
        logger.info(f"데이터베이스 마이그레이션 시작: {db_path}")
        
        conn = sqlite3.connect(str(db_path))
        cursor = conn.cursor()
        
        # user 테이블에 nickname 컬럼이 있는지 확인
        cursor.execute("PRAGMA table_info(user)")
        user_columns = [column[1] for column in cursor.fetchall()]
        
        if 'nickname' not in user_columns:
            logger.info("user 테이블에 nickname 컬럼 추가 중...")
            cursor.execute("ALTER TABLE user ADD COLUMN nickname VARCHAR(80)")
            conn.commit()
            logger.info("user.nickname 컬럼 추가 완료")
        
        # uploaded_file 테이블이 존재하는지 확인
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='uploaded_file'")
        if cursor.fetchone():
            cursor.execute("PRAGMA table_info(uploaded_file)")
            uploaded_file_columns = [column[1] for column in cursor.fetchall()]
            
            if 'uploaded_by' not in uploaded_file_columns:
                logger.info("uploaded_file 테이블에 uploaded_by 컬럼 추가 중...")
                cursor.execute("ALTER TABLE uploaded_file ADD COLUMN uploaded_by INTEGER")
                conn.commit()
                logger.info("uploaded_file.uploaded_by 컬럼 추가 완료")
            
            if 'parent_file_id' not in uploaded_file_columns:
                logger.info("uploaded_file 테이블에 parent_file_id 컬럼 추가 중...")
                cursor.execute("ALTER TABLE uploaded_file ADD COLUMN parent_file_id INTEGER")
                conn.commit()
                logger.info("uploaded_file.parent_file_id 컬럼 추가 완료")
        
        # document_chunk 테이블이 존재하는지 확인
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='document_chunk'")
        if cursor.fetchone():
            cursor.execute("PRAGMA table_info(document_chunk)")
            document_chunk_columns = [column[1] for column in cursor.fetchall()]
            
            if 'chunk_metadata' not in document_chunk_columns:
                logger.info("document_chunk 테이블에 chunk_metadata 컬럼 추가 중...")
                cursor.execute("ALTER TABLE document_chunk ADD COLUMN chunk_metadata TEXT")
                conn.commit()
                logger.info("document_chunk.chunk_metadata 컬럼 추가 완료")
        
        # chat_session 테이블이 존재하는지 확인
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='chat_session'")
        if cursor.fetchone():
            cursor.execute("PRAGMA table_info(chat_session)")
            chat_session_columns = [column[1] for column in cursor.fetchall()]
            
            if 'analysis_model' not in chat_session_columns:
                logger.info("chat_session 테이블에 analysis_model 컬럼 추가 중...")
                cursor.execute("ALTER TABLE chat_session ADD COLUMN analysis_model VARCHAR(100)")
                conn.commit()
                logger.info("chat_session.analysis_model 컬럼 추가 완료")
            
            if 'answer_model' not in chat_session_columns:
                logger.info("chat_session 테이블에 answer_model 컬럼 추가 중...")
                cursor.execute("ALTER TABLE chat_session ADD COLUMN answer_model VARCHAR(100)")
                conn.commit()
                logger.info("chat_session.answer_model 컬럼 추가 완료")
        
        conn.close()
        logger.info("데이터베이스 마이그레이션 완료")
        
    except sqlite3.Error as e:
        logger.error(f"데이터베이스 마이그레이션 중 SQLite 오류 발생: {e}", exc_info=True)
    except Exception as e:
        logger.error(f"데이터베이스 마이그레이션 중 오류 발생: {e}", exc_info=True)


def create_admin_user() -> None:
    """
    초기 관리자 계정 생성
    """
    admin_username = 'soymedia'
    admin_password = 's0ymedi@1@34'
    
    try:
        admin = User.query.filter_by(username=admin_username).first()
        if not admin:
            admin = User(username=admin_username, is_admin=True, is_active=True)
            admin.set_password(admin_password)
            db.session.add(admin)
            db.session.commit()
            logger.info(f'관리자 계정이 생성되었습니다: {admin_username}')
        else:
            logger.debug(f'관리자 계정이 이미 존재합니다: {admin_username}')
    except Exception as e:
        logger.error(f'관리자 계정 생성 중 오류 발생: {e}', exc_info=True)
        db.session.rollback()