app.py

# app.py - 수정된 완전한 Flask 애플리케이션
from flask import Flask, request, jsonify
import logging
import threading
from datetime import datetime
import os

# Flask 앱 생성 (가장 먼저!)
app = Flask(__name__)

# 로깅 설정
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# RAG 시스템 import 추가
try:
    from rag_system import search_tax_law, is_rag_available
    logger.info("✅ RAG 시스템 로드 완료")
    RAG_SYSTEM_AVAILABLE = True
except ImportError as e:
    logger.warning(f"⚠️ RAG 시스템 로드 실패: {e}")
    RAG_SYSTEM_AVAILABLE = False

# 통합 시스템 import (app 생성 후)
try:
    from tax_consultant import (
        handle_tax_consultation_start,
        handle_tax_survey_response, 
        is_tax_question,
        tax_consultant
    )
    logger.info("✅ 통합 취득세 상담 시스템 로드 완료")
    INTEGRATED_SYSTEM_AVAILABLE = True
except ImportError as e:
    logger.warning(f"⚠️ 통합 시스템 로드 실패: {e}")
    INTEGRATED_SYSTEM_AVAILABLE = False

# 기존 AI 함수 (폴백용)
def generate_tax_advice(question):
    """AI 응답 생성 함수 (RAG 시스템 활용)"""
    try:
        # 1순위: RAG 시스템 사용
        if RAG_SYSTEM_AVAILABLE and is_rag_available():
            logger.info("🧠 RAG 시스템으로 답변 생성")
            return search_tax_law(question)
        
        # 2순위: 기존 AI 로직
        logger.info("🤖 기존 AI 시스템으로 답변 생성")
        return f"취득세 상담: {question}에 대한 분석을 완료했습니다."
        
    except Exception as e:
        logger.error(f"AI 응답 생성 오류: {e}")
        return "죄송합니다. 분석 중 오류가 발생했습니다."

@app.route('/api/web/chat', methods=['POST'])
def web_chat():
    """웹 인터페이스 전용 채팅 엔드포인트"""
    try:
        data = request.get_json()
        user_message = data.get('message', '').strip()
        
        if not user_message:
            return jsonify({"error": "메시지가 비어있습니다"}), 400
        
        logger.info(f"💬 웹 채팅 요청: {user_message}")
        
        # RAG 시스템으로 응답 생성
        if RAG_SYSTEM_AVAILABLE and is_rag_available():
            try:
                logger.info("📚 RAG 시스템으로 답변 생성")
                response = search_tax_law(user_message)
                return jsonify({"response": response})
            except Exception as e:
                logger.error(f"❌ RAG 시스템 오류: {e}")
                # 폴백 응답
                return jsonify({"response": generate_tax_advice(user_message)})
        else:
            # RAG 없을 때 기본 응답
            response = generate_tax_advice(user_message)
            return jsonify({"response": response})
            
    except Exception as e:
        logger.error(f"❌ 웹 채팅 오류: {e}")
        return jsonify({"error": str(e)}), 500

# 카카오톡 웹훅은 나중에 사용할 수 있도록 유지하되 비활성화
# @app.route('/api/kakao/webhook', methods=['POST'])  # 주석처리로 비활성화
@app.route('/api/chat', methods=['POST'])
def kakao_webhook_disabled():
    """카카오톡 웹훅 - 현재 비활성화됨"""
    logger.warning("⚠️ 카카오톡 웹훅이 호출되었지만 현재 비활성화 상태입니다")
    return jsonify({"message": "카카오톡 웹훅은 현재 비활성화되어 있습니다"}), 503

# 원래 카카오톡 웹훅 코드는 아래에 보존
def kakao_webhook_original():
    """카카오톡 오픈빌더 웹훅 처리 - 통합 스마트 시스템 + RAG (현재 비활성화)"""
    try:
        data = request.get_json()
        user_utterance = data.get('userRequest', {}).get('utterance', '')
        user_id = data.get('userRequest', {}).get('user', {}).get('id', 'anonymous')
        session_id = f"session_{user_id}"
        
        logger.info(f"📨 카카오톡 - User: {user_id[:8]}***, Msg: {user_utterance}")
        
        if not user_utterance.strip():
            raise ValueError("빈 메시지")
        
        # 🧠 통합 시스템이 사용 가능한 경우 (최우선)
        if INTEGRATED_SYSTEM_AVAILABLE and is_tax_question(user_utterance):
            
            session = tax_consultant.session_manager.get_session(session_id)
            
            if session and session.get('current_step', 0) > 0:
                # 📋 설문 진행 중
                logger.info(f"🔄 설문 응답 처리: 단계 {session['current_step']}")
                
                try:
                    survey_response = handle_tax_survey_response(user_utterance, session_id)
                    logger.info(f"✅ 설문 응답 처리 완료")
                    return survey_response
                except Exception as e:
                    logger.error(f"❌ 설문 처리 오류: {e}")
                    return create_error_response("설문 처리 중 오류가 발생했습니다.")
            
            else:
                # 🆕 새로운 상담 시작
                logger.info(f"🆕 새로운 취득세 상담 시작")
                
                try:
                    analysis_result = tax_consultant.analyzer.analyze_comprehensive_question(user_utterance)
                    missing_conditions = analysis_result.get('missing_conditions', [])
                    confidence_score = analysis_result.get('confidence_score', 0)
                    
                    if not missing_conditions and confidence_score >= 75:
                        # ⚡ 모든 정보 완비 - 즉시 계산
                        logger.info(f"⚡ 즉시 계산 가능 (신뢰도: {confidence_score}%)")
                        consultation_response = handle_tax_consultation_start(user_utterance, session_id, user_id)
                        return consultation_response
                    
                    else:
                        # 📋 설문 필요 - 분석과 함께 진행
                        logger.info(f"📋 설문 필요 (부족: {len(missing_conditions)}개)")
                        
                        consultation_response = handle_tax_consultation_start(user_utterance, session_id, user_id)
                        
                        # 백그라운드에서 RAG 시스템으로 추가 정보 제공
                        def generate_rag_enhancement():
                            try:
                                if RAG_SYSTEM_AVAILABLE and is_rag_available():
                                    logger.info(f"📚 RAG 시스템으로 법령 검색 시작")
                                    rag_result = search_tax_law(user_utterance)
                                    logger.info(f"📚 RAG 검색 완료: {len(rag_result)}자")
                                    # 여기서 추가 정보를 세션에 저장하거나 별도 처리 가능
                            except Exception as e:
                                logger.error(f"❌ RAG 백그라운드 처리 실패: {e}")
                        
                        threading.Thread(target=generate_rag_enhancement, daemon=True).start()
                        
                        return consultation_response
                
                except Exception as e:
                    logger.error(f"❌ 상담 시작 오류: {e}")
                    # 폴백: RAG 시스템 또는 기존 방식으로 처리
                    is_web = 'message' in data
                    return handle_fallback_response(user_utterance, is_web_request=is_web)
        
        # 🔄 폴백 처리 (RAG 시스템 우선)
        else:
            is_web = 'message' in data
            return handle_fallback_response(user_utterance, is_web_request=is_web)
        
    except Exception as e:
        logger.error(f"❌ 채팅 오류: {e}")
        # 웹 인터페이스용 응답
        if 'message' in data:
            return jsonify({"response": f"죄송합니다. 오류가 발생했습니다: {str(e)}"}), 500
        # 카카오톡용 응답
        else:
            return create_error_response("죄송합니다. 일시적인 오류가 발생했습니다. 다시 시도해주세요.")

def handle_fallback_response(user_utterance, is_web_request=False):
    """폴백 응답 처리 (RAG 시스템 우선)"""
    
    # 취득세 관련 키워드 확인
    tax_keywords = ['취득세', '부동산', '집', '아파트', '주택', '세금', '매매', '증여', '상속']
    is_tax_related = any(keyword in user_utterance for keyword in tax_keywords)
    
    if is_tax_related:
        # 🧠 RAG 시스템 우선 시도
        if RAG_SYSTEM_AVAILABLE and is_rag_available():
            try:
                logger.info("📚 RAG 시스템으로 법령 기반 답변 생성")
                rag_response = search_tax_law(user_utterance)
                
                # 웹 인터페이스용 응답
                if is_web_request:
                    return jsonify({"response": rag_response})
                
                # RAG 응답을 카카오톡 형식으로 포맷팅
                formatted_response = f"""🏠 **취득세 법령 상담**
                
                📝 **질문**: {user_utterance}
                
                📚 **법령 기반 답변**:
                {rag_response}
                
                💡 **추가 문의**가 있으시면 언제든 말씀해주세요!"""
                
                return create_simple_response(formatted_response)
                
            except Exception as e:
                logger.error(f"❌ RAG 시스템 오류: {e}")
                # RAG 실패시 기존 방식으로 폴백
        
        # 기존 방식 (RAG 시스템이 없거나 실패한 경우)
        quick_response = f"""🤖 취득세 상담을 시작합니다!
        📝 질문 내용: "{user_utterance}"
        
        🔄 정확한 계산을 위해 분석 중입니다...
        잠시만 기다려주세요! (약 10-15초 소요)
        
        💡 **미리 알려드리는 정보:**
        - 취득세는 지역과 금액에 따라 다름
        - 조정대상지역은 추가 중과세 적용  
        - 다주택자는 별도 세율 적용
        
        정확한 계산 결과를 곧 알려드리겠습니다! ✨"""
        
        # 백그라운드에서 실제 AI 응답 생성
        def generate_delayed_response():
            try:
                ai_response = generate_tax_advice(user_utterance)
                logger.info(f"📤 지연 응답 생성 완료: {len(ai_response)}자")
            except Exception as e:
                logger.error(f"❌ 지연 응답 생성 실패: {e}")
        
        threading.Thread(target=generate_delayed_response, daemon=True).start()
        
        return create_simple_response(quick_response)
    
    else:
        # 일반 인사말
        return create_simple_response(
            "안녕하세요! 🏠 **부동산 취득세 전문 상담** 챗봇입니다.\n\n"
            "취득세 관련 질문을 해주시면 정확한 계산과 상담을 도와드립니다!\n\n"
            "💡 **예시:**\n"
            "• '강남구 아파트 10억 2주택자 취득세'\n"
            "• '부모님이 자녀에게 5억 집 증여 세금'\n"
            "• '서초구 15억 주택 매매 취득세 계산'"
        )

def create_simple_response(text: str) -> dict:
    """단순 텍스트 응답 생성"""
    return jsonify({
        "version": "2.0",
        "template": {
            "outputs": [
                {
                    "simpleText": {
                        "text": text
                    }
                }
            ]
        }
    })
    
def create_error_response(error_message: str) -> tuple:
    """에러 응답 생성"""
    return jsonify({
        "version": "2.0",
        "template": {
            "outputs": [
                {
                    "simpleText": {
                        "text": error_message
                    }
                }
            ]
        }
    }), 500

@app.route('/health', methods=['GET'])
def health_check():
    """시스템 상태 확인"""
    try:
        status_info = {
            "status": "healthy",
            "timestamp": datetime.now().isoformat(),
            "service": "Smart Tax Consultant",
            "integrated_system": INTEGRATED_SYSTEM_AVAILABLE,
            "rag_system": RAG_SYSTEM_AVAILABLE and is_rag_available() if RAG_SYSTEM_AVAILABLE else False
        }
        
        if INTEGRATED_SYSTEM_AVAILABLE:
            active_sessions = len(tax_consultant.session_manager.active_sessions)
            status_info.update({
                "active_sessions": active_sessions,
                "features": {
                    "intelligent_analysis": "enabled",
                    "adaptive_survey": "enabled", 
                    "gift_tax_special": "enabled",
                    "rag_law_search": "enabled" if RAG_SYSTEM_AVAILABLE else "disabled",
                    "timeout_prevention": "enabled"
                }
            })
        else:
            status_info.update({
                "active_sessions": 0,
                "features": {
                    "fallback_mode": "enabled",
                    "rag_law_search": "enabled" if RAG_SYSTEM_AVAILABLE else "disabled",
                    "timeout_prevention": "enabled"
                }
            })
        
        return jsonify(status_info)
        
    except Exception as e:
        return jsonify({
            "status": "unhealthy",
            "error": str(e),
            "timestamp": datetime.now().isoformat()
        }), 500

# RAG 시스템 전용 엔드포인트 추가
@app.route('/api/rag/search', methods=['POST'])
def rag_search():
    """RAG 시스템 전용 법령 검색"""
    try:
        if not RAG_SYSTEM_AVAILABLE:
            return jsonify({"error": "RAG 시스템을 사용할 수 없습니다"}), 503
        
        data = request.get_json()
        question = data.get('question', '')
        
        if not question.strip():
            return jsonify({"error": "질문이 비어있습니다"}), 400
        
        result = search_tax_law(question)
        
        return jsonify({
            "status": "success",
            "question": question,
            "answer": result,
            "timestamp": datetime.now().isoformat()
        })
        
    except Exception as e:
        return jsonify({
            "status": "error",
            "error": str(e),
            "timestamp": datetime.now().isoformat()
        }), 500

@app.route('/cleanup', methods=['POST'])  
def manual_cleanup():
    """수동 세션 정리"""
    try:
        cleanup_results = {}
        
        if INTEGRATED_SYSTEM_AVAILABLE:
            tax_consultant.session_manager.cleanup_old_sessions()
            active_count = len(tax_consultant.session_manager.active_sessions)
            cleanup_results['integrated_system'] = {
                "status": "cleaned",
                "active_sessions": active_count
            }
        else:
            cleanup_results['integrated_system'] = {
                "status": "not_available",
                "active_sessions": 0
            }
        
        return jsonify({
            "status": "success", 
            "message": "시스템 정리 완료",
            "details": cleanup_results
        })
            
    except Exception as e:
        return jsonify({
            "status": "error", 
            "message": str(e)
        }), 500

@app.route('/', methods=['GET'])
def root():
    """웹 인터페이스 제공"""
    html_content = '''<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>🏛️ 취득세 AI 상담봇</title>
    <style>
        body { font-family: -apple-system, BlinkMacSystemFont, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
        .container { max-width: 800px; margin: 0 auto; background: white; border-radius: 10px; padding: 20px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        h1 { color: #2c3e50; text-align: center; margin-bottom: 30px; }
        .chat-container { border: 1px solid #ddd; border-radius: 8px; height: 400px; overflow-y: auto; padding: 15px; background: #fafafa; margin-bottom: 20px; }
        .message { margin: 10px 0; padding: 10px; border-radius: 8px; }
        .user-message { background: #007bff; color: white; margin-left: 20%; text-align: right; }
        .bot-message { background: #e9ecef; color: #333; margin-right: 20%; }
        .input-container { display: flex; gap: 10px; }
        #questionInput { flex: 1; padding: 12px; border: 1px solid #ddd; border-radius: 5px; font-size: 16px; }
        #sendButton { padding: 12px 24px; background: #007bff; color: white; border: none; border-radius: 5px; cursor: pointer; font-size: 16px; }
        #sendButton:hover { background: #0056b3; }
        #sendButton:disabled { background: #ccc; cursor: not-allowed; }
        .status { text-align: center; color: #666; margin: 10px 0; font-size: 14px; }
        .samples { margin-top: 20px; padding: 15px; background: #f8f9fa; border-radius: 5px; }
        .samples h3 { margin-top: 0; color: #495057; }
        .sample-btn { background: #28a745; color: white; border: none; padding: 8px 16px; margin: 5px; border-radius: 5px; cursor: pointer; font-size: 14px; }
        .sample-btn:hover { background: #218838; }
    </style>
</head>
<body>
    <div class="container">
        <h1>🏛️ 취득세 AI 상담봇</h1>
        <div class="status">
            ✅ RAG 시스템: ''' + ('활성화' if RAG_SYSTEM_AVAILABLE else '비활성화') + '''
            | 🖥️ 환경: 허깅페이스 스페이스 GPU
        </div>
        
        <div class="chat-container" id="chatContainer">
            <div class="message bot-message">
                안녕하세요! 저는 취득세 AI 상담봇입니다. 🏠<br>
                취득세 관련 궁금한 점을 자유롭게 질문해주세요!
            </div>
        </div>
        
        <div class="input-container">
            <input type="text" id="questionInput" placeholder="취득세 관련 질문을 입력하세요..." 
                   onkeypress="if(event.key==='Enter') sendMessage()">
            <button id="sendButton" onclick="sendMessage()">질문하기</button>
        </div>
        
        <div class="samples">
            <h3>💡 샘플 질문들 (클릭하면 자동 입력)</h3>
            <button class="sample-btn" onclick="setSample('취득세율이 얼마인가요?')">취득세율</button>
            <button class="sample-btn" onclick="setSample('1세대 1주택자 감면 혜택은?')">1세대1주택 감면</button>
            <button class="sample-btn" onclick="setSample('신혼부부 취득세 특례는?')">신혼부부 특례</button>
            <button class="sample-btn" onclick="setSample('농지 취득세 계산방법은?')">농지 취득세</button>
            <button class="sample-btn" onclick="setSample('다주택자 중과세율은?')">중과세율</button>
        </div>
    </div>

    <script>
        function addMessage(message, isUser) {
            const chatContainer = document.getElementById('chatContainer');
            const messageDiv = document.createElement('div');
            messageDiv.className = 'message ' + (isUser ? 'user-message' : 'bot-message');
            messageDiv.innerHTML = message.replace(/\\n/g, '<br>');
            chatContainer.appendChild(messageDiv);
            chatContainer.scrollTop = chatContainer.scrollHeight;
        }

        function setSample(question) {
            document.getElementById('questionInput').value = question;
        }

        async function sendMessage() {
            const input = document.getElementById('questionInput');
            const button = document.getElementById('sendButton');
            const question = input.value.trim();
            
            if (!question) return;
            
            addMessage(question, true);
            input.value = '';
            button.disabled = true;
            button.textContent = '답변 생성 중...';
            
            try {
                const response = await fetch('/api/web/chat', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ message: question })
                });
                
                const data = await response.json();
                
                if (data.response) {
                    addMessage(data.response, false);
                } else {
                    addMessage('죄송합니다. 응답을 생성할 수 없습니다.', false);
                }
            } catch (error) {
                addMessage('오류가 발생했습니다: ' + error.message, false);
            }
            
            button.disabled = false;
            button.textContent = '질문하기';
        }
    </script>
</body>
</html>'''
    return html_content

@app.route('/api/info', methods=['GET'])
def api_info():
    """API 정보 및 상태 제공"""
    return jsonify({
        "service": "Smart Tax Consultant with RAG",
        "version": "2.0",
        "systems": {
            "integrated_system": INTEGRATED_SYSTEM_AVAILABLE,
            "rag_system": RAG_SYSTEM_AVAILABLE and is_rag_available() if RAG_SYSTEM_AVAILABLE else False
        },
        "endpoints": {
            "web_chat": "/api/web/chat",
            "kakao_webhook": "/api/chat (disabled)",
            "rag_search": "/api/rag/search",
            "health": "/health", 
            "cleanup": "/cleanup"
        }
    })

if __name__ == '__main__':
    logger.info("🚀 스마트 취득세 상담 시스템 + RAG 시작")
    logger.info(f"📊 통합 시스템: {'사용 가능' if INTEGRATED_SYSTEM_AVAILABLE else '폴백 모드'}")
    logger.info(f"📚 RAG 시스템: {'사용 가능' if RAG_SYSTEM_AVAILABLE else '사용 불가'}")
    
    # 환경변수에서 포트 읽기 (HuggingFace Spaces 호환)
    port = int(os.getenv('PORT', 7860))
    app.run(host='0.0.0.0', port=port, debug=False)