app.py

import gradio as gr
import os
import json
import requests
from datetime import datetime
import time
from typing import List, Dict, Any, Generator, Tuple
import logging
import re

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

# 추가 임포트
from bs4 import BeautifulSoup
from urllib.parse import urlparse
import urllib.request

# Gemini API 임포트
try:
    from google import genai
    from google.genai import types
    GEMINI_AVAILABLE = True
except ImportError:
    GEMINI_AVAILABLE = False
    logger.warning("Google Gemini API가 설치되지 않았습니다. pip install google-genai로 설치하세요.")

# 환경 변수에서 토큰 가져오기
FRIENDLI_TOKEN = os.getenv("FRIENDLI_TOKEN", "YOUR_FRIENDLI_TOKEN")
BAPI_TOKEN = os.getenv("BAPI_TOKEN", "YOUR_BRAVE_API_TOKEN")
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "YOUR_GEMINI_API_KEY")
API_URL = "https://api.friendli.ai/dedicated/v1/chat/completions"
BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search"
MODEL_ID = "dep89a2fld32mcm"
TEST_MODE = os.getenv("TEST_MODE", "false").lower() == "true"

# 전역 변수
conversation_history = []

class WuxingLLMSystem:
    """오행·오상 기반 협력적 LLM 시스템"""
    
    def __init__(self):
        self.token = FRIENDLI_TOKEN
        self.bapi_token = BAPI_TOKEN
        self.gemini_api_key = GEMINI_API_KEY
        self.api_url = API_URL
        self.brave_url = BRAVE_SEARCH_URL
        self.model_id = MODEL_ID
        self.test_mode = TEST_MODE or (self.token == "YOUR_FRIENDLI_TOKEN")
        self.use_gemini = False
        self.gemini_client = None
        
        # 오행 역할 정의
        self.wuxing_roles = {
            "wood": {
                "name": "감독관 (팀장)",
                "virtue": "仁",
                "element": "木",
                "traits": "포용·성장형 리더",
                "expertise": "비전 제시, 팀 조율, 인재 육성",
                "color": "#10b981"  # Green
            },
            "fire": {
                "name": "전략·기획 리더",
                "virtue": "義",
                "element": "火",
                "traits": "열정·결단, 개척 정신",
                "expertise": "중·장기 로드맵, 사업 모델 설계, 리스크-보상 시나리오",
                "color": "#ef4444"  # Red
            },
            "metal": {
                "name": "아키텍처 & 표준 책임",
                "virtue": "禮",
                "element": "金",
                "traits": "구조화·정밀, 시스템 설계 마스터",
                "expertise": "기술·데이터 아키텍처, 표준 수립, 품질·확장성 검증",
                "color": "#f59e0b"  # Gold
            },
            "water": {
                "name": "도구 활용 R&D 스페셜리스트",
                "virtue": "智",
                "element": "水",
                "traits": "분석·호기심, IT·AI 도구 전문가",
                "expertise": "최신 기술·시장 조사, 프로토타입 개발, 자동화·생산성 툴",
                "color": "#3b82f6"  # Blue
            },
            "earth": {
                "name": "실행·운영·품질 담당",
                "virtue": "信",
                "element": "土",
                "traits": "신뢰·성실, 실행력",
                "expertise": "일정·예산·리소스 관리, 운영 최적화, 품질 보증",
                "color": "#a855f7"  # Purple
            }
        }
        
        if self.test_mode:
            logger.warning("테스트 모드로 실행됩니다.")
        
    def set_llm_mode(self, mode: str):
        """LLM 모드 설정"""
        if mode == "commercial" and GEMINI_AVAILABLE and self.gemini_api_key != "YOUR_GEMINI_API_KEY":
            self.use_gemini = True
            if not self.gemini_client:
                self.gemini_client = genai.Client(api_key=self.gemini_api_key)
            logger.info("Gemini 2.5 Pro 모드로 전환되었습니다.")
        else:
            self.use_gemini = False
            logger.info("기본 LLM 모드로 전환되었습니다.")
    
    def create_headers(self):
        """API 헤더 생성"""
        return {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/json"
        }
    
    def create_brave_headers(self):
        """Brave API 헤더 생성"""
        return {
            "Accept": "application/json",
            "Accept-Encoding": "gzip",
            "X-Subscription-Token": self.bapi_token
        }
    
    def create_wood_initial_prompt(self, user_query: str, search_results: Dict = None) -> str:
        """木(감독관) 초기 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n웹 검색 결과:\n{self._format_search_results(search_results)}"
        
        return f"""당신은 仁(인자함)의 덕목을 지닌 木의 기운을 가진 감독관입니다.
포용적이고 성장지향적인 리더십으로 팀을 이끕니다.

사용자 질문: {user_query}
{search_info}

팀장으로서 이 질문에 대해:
1. 전체적인 비전과 방향성을 제시하세요
2. 각 팀원(火, 土, 金, 水)의 역할과 기여 방향을 설계하세요
3. 성장과 발전의 관점에서 핵심 목표를 설정하세요
4. 팀 전체가 조화롭게 협력할 수 있는 프레임워크를 제시하세요
5. 검색 결과를 참고하여 최신 트렌드와 모범 사례를 반영하세요

[핵심 키워드]: 5-7개의 조사가 필요한 키워드를 제시하세요"""
    
    def create_fire_strategy_prompt(self, user_query: str, wood_response: str, critic_feedback: str, search_results: Dict = None) -> str:
        """火(전략기획) 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n웹 검색 결과:\n{self._format_search_results(search_results)}"
        
        return f"""당신은 義(정의로움)의 덕목을 지닌 火의 기운을 가진 전략·기획 리더입니다.
열정과 결단력으로 혁신적인 전략을 수립합니다.

사용자 질문: {user_query}

감독관(木)의 비전:
{wood_response}

비평자의 피드백:
{critic_feedback}
{search_info}

전략기획 리더로서:
1. 중·장기 로드맵을 구체적으로 수립하세요
2. 혁신적인 사업 모델을 설계하세요
3. 리스크와 기회 분석을 수행하세요
4. 경쟁 우위 확보 전략을 제시하세요
5. 비평자의 피드백을 반영하여 전략을 보완하세요
6. 필요한 추가 검색 키워드를 제시하세요: [추가 검색]"""
    
    def create_earth_execution_prompt(self, user_query: str, fire_response: str, critic_feedback: str, search_results: Dict = None) -> str:
        """土(실행운영) 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n웹 검색 결과:\n{self._format_search_results(search_results)}"
        
        return f"""당신은 信(신뢰)의 덕목을 지닌 土의 기운을 가진 실행·운영·품질 담당자입니다.
성실함과 실행력으로 계획을 현실로 만듭니다.

사용자 질문: {user_query}

전략기획(火)의 전략:
{fire_response}

비평자의 피드백:
{critic_feedback}
{search_info}

실행운영 담당자로서:
1. 구체적인 실행 계획과 일정을 수립하세요
2. 필요한 리소스와 예산을 산정하세요
3. 품질 관리 기준과 프로세스를 정의하세요
4. 리스크 대응 계획을 수립하세요
5. 성과 측정 지표를 설정하세요
6. 추가 조사가 필요한 실행 관련 키워드: [추가 검색]"""
    
    def create_metal_architecture_prompt(self, user_query: str, earth_response: str, critic_feedback: str, search_results: Dict = None) -> str:
        """金(아키텍처) 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n웹 검색 결과:\n{self._format_search_results(search_results)}"
        
        return f"""당신은 禮(예의·질서)의 덕목을 지닌 金의 기운을 가진 아키텍처 & 표준 책임자입니다.
정밀함과 구조화 능력으로 완벽한 시스템을 설계합니다.

사용자 질문: {user_query}

실행운영(土)의 계획:
{earth_response}

비평자의 피드백:
{critic_feedback}
{search_info}

아키텍처 책임자로서:
1. 전체 시스템의 기술·데이터 아키텍처를 설계하세요
2. 코딩/API·데이터·보안 표준을 수립하세요
3. 확장성과 호환성을 고려한 프레임워크를 제시하세요
4. 품질 검증 체계와 기준을 정의하세요
5. 기술적 제약사항과 해결방안을 제시하세요
6. 기술 아키텍처 관련 추가 검색: [추가 검색]"""
    
    def create_water_rd_prompt(self, user_query: str, metal_response: str, critic_feedback: str, search_results: Dict = None) -> str:
        """水(R&D) 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n최신 기술 조사 결과:\n{self._format_search_results(search_results)}"
        
        return f"""당신은 智(지혜)의 덕목을 지닌 水의 기운을 가진 도구 활용 R&D 스페셜리스트입니다.
분석력과 호기심으로 최신 기술을 탐구하고 혁신합니다.

사용자 질문: {user_query}

아키텍처(金)의 설계:
{metal_response}

비평자의 피드백:
{critic_feedback}
{search_info}

R&D 스페셜리스트로서:
1. 최신 기술 트렌드와 도구를 분석하세요
2. 혁신적인 프로토타입 개발 방안을 제시하세요
3. 자동화와 생산성 향상 도구를 추천하세요
4. 기술 도입의 ROI와 실현 가능성을 평가하세요
5. 팀 교육과 기술 전파 계획을 수립하세요
6. 미래 기술 관련 추가 검색: [추가 검색]"""
    
    def create_wood_final_prompt(self, user_query: str, all_responses: Dict, all_critics: List) -> str:
        """木(감독관) 최종 종합 프롬프트"""
        return f"""당신은 仁(인자함)의 덕목을 지닌 木의 기운을 가진 감독관입니다.
팀 전체의 의견을 종합하여 최종 결정을 내립니다.

사용자 질문: {user_query}

팀원들의 기여:
- 火(전략기획): {all_responses['fire']}
- 土(실행운영): {all_responses['earth']}
- 金(아키텍처): {all_responses['metal']}
- 水(R&D): {all_responses['water']}

비평자의 피드백 이력:
{self._format_critic_history(all_critics)}

팀장으로서 최종 종합 보고서를 작성하세요:
1. 각 팀원의 기여를 통합한 종합 솔루션
2. 실행 우선순위와 단계별 로드맵
3. 예상 성과와 성공 지표
4. 팀 전체의 시너지 창출 방안
5. 지속적 개선과 성장 계획

마크다운 형식을 활용하여 전문적이고 체계적으로 작성하세요."""
    
    def create_critic_prompt(self, stage: str, content: str, context: str = "", search_results: Dict = None) -> str:
        """중립적 비평자 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n참고 검색 결과:\n{self._format_search_results(search_results)}"
        
        return f"""당신은 중립적이고 논리적인 비평자입니다.
편견 없이 합리적이고 건설적인 비평을 제공합니다.

현재 단계: {stage}

분석 대상:
{content}

{f"이전 맥락: {context}" if context else ""}
{search_info}

다음 관점에서 비평하세요:
1. 논리적 일관성과 타당성
2. 실현 가능성과 실용성
3. 누락된 중요 요소
4. 개선 가능한 부분
5. 강점과 약점의 균형잡힌 평가
6. 최신 트렌드와 모범 사례 대비 평가

건설적이고 구체적인 피드백을 제공하되, 다음 단계 담당자가 
개선할 수 있는 실질적인 제안을 포함하세요.

필요시 추가 검색이 필요한 키워드를 제안하세요: [비평 검색]"""
    
    def _format_search_results(self, search_results: Dict) -> str:
        """검색 결과 포맷팅"""
        if not search_results:
            return "검색 결과 없음"
        
        formatted = ""
        for keyword, results in search_results.items():
            formatted += f"\n**{keyword}:**\n"
            for i, result in enumerate(results[:5], 1):
                formatted += f"{i}. {result.get('title', 'N/A')} (신뢰도: {result.get('credibility_score', 0):.2f})\n"
                formatted += f"   {result.get('description', 'N/A')[:150]}...\n"
        return formatted
    
    def _format_critic_history(self, critics: List) -> str:
        """비평 이력 포맷팅"""
        if not critics:
            return "비평 이력 없음"
        
        formatted = ""
        stages = ["木 초기", "火 전략", "土 실행", "金 아키텍처", "水 R&D"]
        for i, critic in enumerate(critics):
            if i < len(stages):
                formatted += f"\n**{stages[i]} 단계 비평:**\n{critic}\n"
        return formatted
    
    def extract_keywords(self, response: str, keyword_marker: str = "[핵심 키워드]") -> List[str]:
        """응답에서 키워드 추출 (범용)"""
        keywords = []
        
        # 다양한 키워드 마커 패턴
        patterns = [
            rf'\{keyword_marker}:\s*(.+)',
            r'\[추가 검색\]:\s*(.+)',
            r'\[비평 검색\]:\s*(.+)'
        ]
        
        for pattern in patterns:
            match = re.search(pattern, response, re.IGNORECASE)
            if match:
                keyword_str = match.group(1)
                new_keywords = [k.strip() for k in keyword_str.split(',') if k.strip()]
                keywords.extend(new_keywords)
        
        # 중복 제거
        keywords = list(dict.fromkeys(keywords))
        
        if not keywords:
            # 기본 키워드 생성
            keywords = ["best practices", "implementation", "case studies", "latest trends"]
        
        return keywords[:7]
    
    def calculate_credibility_score(self, result: Dict) -> float:
        """검색 결과 신뢰도 계산"""
        score = 0.5
        url = result.get('url', '')
        
        trusted_domains = ['.edu', '.gov', '.org', 'wikipedia.org', 'nature.com', 
                          'ieee.org', 'acm.org', 'github.com']
        
        for domain in trusted_domains:
            if domain in url:
                score += 0.2
                break
        
        if url.startswith('https://'):
            score += 0.1
        
        if len(result.get('title', '')) > 20:
            score += 0.05
        if len(result.get('description', '')) > 50:
            score += 0.05
        
        spam_keywords = ['buy now', 'sale', 'discount', 'click here']
        if any(spam in (result.get('title', '') + result.get('description', '')).lower() 
               for spam in spam_keywords):
            score -= 0.3
        
        return max(0, min(1, score))
    
    def brave_search(self, query: str) -> List[Dict]:
        """Brave Search API 호출"""
        if self.test_mode or self.bapi_token == "YOUR_BRAVE_API_TOKEN":
            test_results = []
            for i in range(5):
                test_results.append({
                    "title": f"{query} - Best Practices {i+1}",
                    "description": f"Comprehensive guide on {query} with proven methodologies.",
                    "url": f"https://example{i+1}.com/{query.replace(' ', '-')}",
                    "credibility_score": 0.7 + (i * 0.05)
                })
            return test_results
        
        try:
            params = {
                "q": query,
                "count": 10,
                "safesearch": "moderate"
            }
            
            response = requests.get(
                self.brave_url,
                headers=self.create_brave_headers(),
                params=params,
                timeout=10
            )
            
            if response.status_code == 200:
                data = response.json()
                results = []
                for item in data.get("web", {}).get("results", []):
                    result = {
                        "title": item.get("title", ""),
                        "description": item.get("description", ""),
                        "url": item.get("url", ""),
                        "credibility_score": self.calculate_credibility_score(item)
                    }
                    results.append(result)
                
                results.sort(key=lambda x: x['credibility_score'], reverse=True)
                return results
            else:
                logger.error(f"Brave API 오류: {response.status_code}")
                return []
                
        except Exception as e:
            logger.error(f"Brave 검색 중 오류: {str(e)}")
            return []
    
    def call_gemini_streaming(self, messages: List[Dict[str, str]], role: str) -> Generator[str, None, None]:
        """Gemini API 스트리밍 호출"""
        if not self.gemini_client:
            yield "❌ Gemini API 클라이언트가 초기화되지 않았습니다."
            return
        
        try:
            contents = []
            for msg in messages:
                if msg["role"] == "user":
                    contents.append(types.Content(
                        role="user",
                        parts=[types.Part.from_text(text=msg["content"])]
                    ))
            
            generate_content_config = types.GenerateContentConfig(
                temperature=0.7,
                top_p=0.8,
                max_output_tokens=4096,
                response_mime_type="text/plain"
            )
            
            for chunk in self.gemini_client.models.generate_content_stream(
                model="gemini-2.5-pro",
                contents=contents,
                config=generate_content_config,
            ):
                if chunk.text:
                    yield chunk.text
                    
        except Exception as e:
            logger.error(f"Gemini API 오류: {str(e)}")
            yield f"❌ Gemini API 오류: {str(e)}"
    
    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str) -> Generator[str, None, None]:
        """스트리밍 LLM API 호출"""
        if self.use_gemini:
            yield from self.call_gemini_streaming(messages, role)
            return
        
        if self.test_mode:
            test_response = f"이것은 {role} 역할의 테스트 응답입니다.\n"
            test_response += f"사용자 질문에 대한 {role}의 관점에서 분석한 내용입니다.\n"
            test_response += "1. 첫 번째 핵심 포인트\n2. 두 번째 핵심 포인트\n3. 세 번째 핵심 포인트"
            
            words = test_response.split()
            for i in range(0, len(words), 3):
                chunk = " ".join(words[i:i+3])
                yield chunk + " "
                time.sleep(0.05)
            return
        
        try:
            payload = {
                "model": self.model_id,
                "messages": messages,
                "max_tokens": 4096,
                "temperature": 0.7,
                "stream": True
            }
            
            response = requests.post(
                self.api_url,
                headers=self.create_headers(),
                json=payload,
                stream=True,
                timeout=10
            )
            
            if response.status_code != 200:
                yield f"❌ API 오류: {response.status_code}"
                return
            
            for line in response.iter_lines():
                if line:
                    line = line.decode('utf-8')
                    if line.startswith("data: "):
                        data = line[6:]
                        if data == "[DONE]":
                            break
                        try:
                            chunk = json.loads(data)
                            if "choices" in chunk and chunk["choices"]:
                                content = chunk["choices"][0].get("delta", {}).get("content", "")
                                if content:
                                    yield content
                        except json.JSONDecodeError:
                            continue
                            
        except Exception as e:
            logger.error(f"스트리밍 중 오류: {str(e)}")
            yield f"❌ 오류 발생: {str(e)}"

# 시스템 인스턴스 생성
wuxing_system = WuxingLLMSystem()

def process_wuxing_query(user_query: str, llm_mode: str):
    """오행 기반 쿼리 처리"""
    if not user_query:
        return "", "", "", "", "", "", "", "❌ 질문을 입력해주세요."
    
    wuxing_system.set_llm_mode(llm_mode)
    
    all_responses = {}
    all_critics = []
    all_search_results = {}
    
    try:
        # 0. 초기 검색 수행
        initial_keywords = [user_query] + ["best practices", "latest trends", "case studies"]
        wood_search_results = {}
        
        status_text = "🔍 초기 웹 검색 수행 중..."
        yield "", "", "", "", "", "", "", status_text
        
        for keyword in initial_keywords[:3]:
            results = wuxing_system.brave_search(keyword)
            if results:
                wood_search_results[keyword] = results
                all_search_results[f"초기-{keyword}"] = results
        
        # 1. 木(감독관) 초기 분석
        wood_prompt = wuxing_system.create_wood_initial_prompt(user_query, wood_search_results)
        wood_response = ""
        
        wood_text = "🌳 **木 - 감독관** (仁)\n🔄 분석 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": wood_prompt}], "wood"
        ):
            wood_response += chunk
            wood_text = f"🌳 **木 - 감독관** (仁)\n{wood_response}"
            yield wood_text, "", "", "", "", "", "", "🌳 감독관이 비전을 수립 중..."
        
        all_responses['wood_initial'] = wood_response
        
        # 키워드 추출
        keywords = wuxing_system.extract_keywords(wood_response)
        
        # 2. 木 비평 + 비평자 검색
        critic_search = {}
        for keyword in keywords[:2]:
            results = wuxing_system.brave_search(f"{keyword} analysis")
            if results:
                critic_search[keyword] = results
                all_search_results[f"비평1-{keyword}"] = results
        
        critic_prompt = wuxing_system.create_critic_prompt("木 초기 분석", wood_response, search_results=critic_search)
        critic_response = ""
        
        critic_text = "🔍 **중립적 비평자**\n[木 분석 비평] 🔄 비평 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            critic_text = f"🔍 **중립적 비평자**\n[木 분석 비평]\n{critic_response}"
            yield wood_text, "", "", "", "", critic_text, "", "🔍 비평자가 분석 중..."
        
        all_critics.append(critic_response)
        
        # 3. 火(전략기획) + 검색
        # 비평자가 제안한 추가 키워드 추출
        critic_keywords = wuxing_system.extract_keywords(critic_response, "[비평 검색]")
        fire_search = {}
        
        for keyword in (keywords[:2] + critic_keywords[:2]):
            results = wuxing_system.brave_search(f"{user_query} {keyword} strategy")
            if results:
                fire_search[keyword] = results
                all_search_results[f"火-{keyword}"] = results
        
        fire_prompt = wuxing_system.create_fire_strategy_prompt(user_query, wood_response, critic_response, fire_search)
        fire_response = ""
        
        fire_text = "🔥 **火 - 전략·기획 리더** (義)\n🔄 전략 수립 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": fire_prompt}], "fire"
        ):
            fire_response += chunk
            fire_text = f"🔥 **火 - 전략·기획 리더** (義)\n{fire_response}"
            yield wood_text, fire_text, "", "", "", critic_text, "", "🔥 전략 수립 중..."
        
        all_responses['fire'] = fire_response
        
        # 4. 火 비평
        fire_keywords = wuxing_system.extract_keywords(fire_response, "[추가 검색]")
        critic_search = {}
        
        for keyword in fire_keywords[:2]:
            results = wuxing_system.brave_search(keyword)
            if results:
                critic_search[keyword] = results
                all_search_results[f"비평2-{keyword}"] = results
        
        critic_prompt = wuxing_system.create_critic_prompt("火 전략기획", fire_response, wood_response, critic_search)
        critic_response = ""
        
        critic_text += "\n\n---\n\n[火 전략 비평] 🔄 비평 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            temp_text = all_critics[0] + f"\n\n---\n\n[火 전략 비평]\n{critic_response}"
            critic_text = f"🔍 **중립적 비평자**\n[木 분석 비평]\n{temp_text}"
            yield wood_text, fire_text, "", "", "", critic_text, "", "🔍 전략 비평 중..."
        
        all_critics.append(critic_response)
        
        # 5. 土(실행운영)
        earth_search = {}
        for keyword in ["implementation", "resource management", "quality assurance"]:
            results = wuxing_system.brave_search(f"{user_query} {keyword}")
            if results:
                earth_search[keyword] = results
                all_search_results[f"土-{keyword}"] = results
        
        earth_prompt = wuxing_system.create_earth_execution_prompt(user_query, fire_response, critic_response, earth_search)
        earth_response = ""
        
        earth_text = "🏔️ **土 - 실행·운영·품질** (信)\n🔄 실행 계획 수립 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": earth_prompt}], "earth"
        ):
            earth_response += chunk
            earth_text = f"🏔️ **土 - 실행·운영·품질** (信)\n{earth_response}"
            yield wood_text, fire_text, earth_text, "", "", critic_text, "", "🏔️ 실행 계획 수립 중..."
        
        all_responses['earth'] = earth_response
        
        # 6. 土 비평
        critic_search = {}
        results = wuxing_system.brave_search(f"{user_query} execution challenges")
        if results:
            critic_search["execution"] = results
            all_search_results["비평3-execution"] = results
        
        critic_prompt = wuxing_system.create_critic_prompt("土 실행계획", earth_response, fire_response, critic_search)
        critic_response = ""
        
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            yield wood_text, fire_text, earth_text, "", "", critic_text, "", "🔍 실행 비평 중..."
        
        all_critics.append(critic_response)
        
        # 7. 金(아키텍처)
        metal_search = {}
        for keyword in ["architecture", "standards", "system design", "scalability"]:
            results = wuxing_system.brave_search(f"{user_query} {keyword}")
            if results:
                metal_search[keyword] = results
                all_search_results[f"金-{keyword}"] = results
        
        metal_prompt = wuxing_system.create_metal_architecture_prompt(user_query, earth_response, critic_response, metal_search)
        metal_response = ""
        
        metal_text = "⚙️ **金 - 아키텍처 & 표준** (禮)\n🔄 아키텍처 설계 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": metal_prompt}], "metal"
        ):
            metal_response += chunk
            metal_text = f"⚙️ **金 - 아키텍처 & 표준** (禮)\n{metal_response}"
            yield wood_text, fire_text, earth_text, metal_text, "", critic_text, "", "⚙️ 아키텍처 설계 중..."
        
        all_responses['metal'] = metal_response
        
        # 8. 金 비평
        critic_search = {}
        results = wuxing_system.brave_search(f"{user_query} technical constraints")
        if results:
            critic_search["constraints"] = results
            all_search_results["비평4-constraints"] = results
        
        critic_prompt = wuxing_system.create_critic_prompt("金 아키텍처", metal_response, earth_response, critic_search)
        critic_response = ""
        
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            yield wood_text, fire_text, earth_text, metal_text, "", critic_text, "", "🔍 아키텍처 비평 중..."
        
        all_critics.append(critic_response)
        
        # 9. 水(R&D)
        water_search = {}
        for keyword in ["innovation", "emerging technology", "R&D", "automation tools"]:
            results = wuxing_system.brave_search(f"{user_query} {keyword}")
            if results:
                water_search[keyword] = results
                all_search_results[f"水-{keyword}"] = results
        
        water_prompt = wuxing_system.create_water_rd_prompt(user_query, metal_response, critic_response, water_search)
        water_response = ""
        
        water_text = "💧 **水 - R&D 스페셜리스트** (智)\n🔄 혁신 방안 연구 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": water_prompt}], "water"
        ):
            water_response += chunk
            water_text = f"💧 **水 - R&D 스페셜리스트** (智)\n{water_response}"
            yield wood_text, fire_text, earth_text, metal_text, water_text, critic_text, "", "💧 혁신 연구 중..."
        
        all_responses['water'] = water_response
        
        # 10. 水 비평
        critic_search = {}
        results = wuxing_system.brave_search(f"{user_query} future trends")
        if results:
            critic_search["trends"] = results
            all_search_results["비평5-trends"] = results
        
        critic_prompt = wuxing_system.create_critic_prompt("水 R&D", water_response, metal_response, critic_search)
        critic_response = ""
        
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            yield wood_text, fire_text, earth_text, metal_text, water_text, critic_text, "", "🔍 R&D 비평 중..."
        
        all_critics.append(critic_response)
        
        # 11. 木(감독관) 최종 종합
        wood_final_prompt = wuxing_system.create_wood_final_prompt(user_query, all_responses, all_critics)
        wood_final_response = ""
        
        wood_text += "\n\n---\n\n🌳 **최종 종합 보고서**\n🔄 작성 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": wood_final_prompt}], "wood"
        ):
            wood_final_response += chunk
            temp_text = all_responses['wood_initial'] + f"\n\n---\n\n🌳 **최종 종합 보고서**\n{wood_final_response}"
            wood_text = f"🌳 **木 - 감독관** (仁)\n{temp_text}"
            yield wood_text, fire_text, earth_text, metal_text, water_text, critic_text, "", "🌳 최종 보고서 작성 중..."
        
        # 최종 보고서 생성
        final_report = f"""# 🌟 오행 협력 시스템 최종 종합 보고서

## 📌 사용자 질문
> **{user_query}**

---

## 🌳 팀장 최종 종합 (木 - 仁)

{wood_final_response}

---

## 📊 오행 팀원 기여 요약

### 🔥 전략·기획 (火 - 義)
{fire_response[:500]}...

### 🏔️ 실행·운영 (土 - 信)
{earth_response[:500]}...

### ⚙️ 아키텍처 (金 - 禮)
{metal_response[:500]}...

### 💧 R&D 혁신 (水 - 智)
{water_response[:500]}...

---

## 🔍 중립적 비평 핵심 통찰

### 주요 개선사항
{all_critics[-1][:400]}...

---

## 📈 성과 지표

| 항목 | 내용 |
|------|------|
| **웹 검색 수행** | {len(all_search_results)}개 키워드 |
| **수집 정보량** | {sum(len(r) for r in all_search_results.values())}개 결과 |
| **협력 단계** | 11단계 (5인 + 5비평 + 종합) |
| **사용 모델** | {'Gemini 2.5 Pro' if wuxing_system.use_gemini else '기본 LLM'} |

---

## 🎯 핵심 성공 요인

1. **조화로운 협력**: 오행의 상생 관계를 통한 시너지 창출
2. **다각적 검토**: 5가지 전문성과 중립적 비평의 균형
3. **데이터 기반**: {len(all_search_results)}회의 웹 검색을 통한 최신 정보 반영
4. **실행 가능성**: 구체적이고 단계별 접근 방안 제시

---

*생성 시각: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
*오행 협력 시스템 - 仁義禮智信의 조화*"""
        
        status_text = f"✅ 오행 협력 프로세스 완료! ({len(all_search_results)} 키워드, {sum(len(r) for r in all_search_results.values())} 검색결과)"
        yield wood_text, fire_text, earth_text, metal_text, water_text, critic_text, final_report, status_text
        
    except Exception as e:
        error_msg = f"❌ 처리 중 오류: {str(e)}"
        yield "", "", "", "", "", "", "", error_msg

def clear_wuxing():
    """초기화"""
    return "", "", "", "", "", "", "", "🔄 초기화되었습니다."

# CSS 스타일
css = """
.gradio-container {
    font-family: 'Arial', sans-serif;
}
.wood-box textarea {
    border-left: 4px solid #10b981 !important;
    background-color: #f0fdf4 !important;
}
.fire-box textarea {
    border-left: 4px solid #ef4444 !important;
    background-color: #fef2f2 !important;
}
.earth-box textarea {
    border-left: 4px solid #a855f7 !important;
    background-color: #faf5ff !important;
}
.metal-box textarea {
    border-left: 4px solid #f59e0b !important;
    background-color: #fffbeb !important;
}
.water-box textarea {
    border-left: 4px solid #3b82f6 !important;
    background-color: #eff6ff !important;
}
.critic-box textarea {
    border-left: 4px solid #6b7280 !important;
    background-color: #f9fafb !important;
}
.final-report-box {
    border: 2px solid #10b981 !important;
    border-radius: 8px !important;
    padding: 20px !important;
    background: linear-gradient(to bottom, #f0fdf4, #ffffff) !important;
    margin-top: 10px !important;
    font-size: 14px !important;
    max-height: 800px !important;
    overflow-y: auto !important;
    line-height: 1.8 !important;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1) !important;
}
.final-report-box h1 {
    color: #065f46 !important;
    font-size: 28px !important;
    margin-bottom: 16px !important;
    text-align: center !important;
    font-weight: bold !important;
}
.final-report-box h2 {
    color: #047857 !important;
    font-size: 22px !important;
    margin-top: 20px !important;
    margin-bottom: 12px !important;
    border-bottom: 2px solid #10b981 !important;
    padding-bottom: 8px !important;
}
.final-report-box h3 {
    color: #059669 !important;
    font-size: 18px !important;
    margin-top: 16px !important;
    margin-bottom: 10px !important;
    font-weight: 600 !important;
}
.final-report-box h4 {
    color: #10b981 !important;
    font-size: 16px !important;
    margin-top: 12px !important;
    margin-bottom: 8px !important;
}
.final-report-box table {
    border-collapse: collapse !important;
    width: 100% !important;
    margin: 20px 0 !important;
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1) !important;
}
.final-report-box th, .final-report-box td {
    border: 1px solid #d1d5db !important;
    padding: 12px 14px !important;
    text-align: left !important;
}
.final-report-box th {
    background-color: #065f46 !important;
    font-weight: bold !important;
    color: #ffffff !important;
    text-transform: uppercase !important;
    font-size: 13px !important;
    letter-spacing: 0.5px !important;
}
.final-report-box tr:nth-child(even) {
    background-color: #f9fafb !important;
}
.final-report-box tr:hover {
    background-color: #f0fdf4 !important;
    transition: background-color 0.2s !important;
}
.final-report-box code {
    background-color: #ecfdf5 !important;
    padding: 3px 8px !important;
    border-radius: 4px !important;
    font-family: 'Consolas', 'Monaco', monospace !important;
    color: #047857 !important;
    font-size: 13px !important;
    border: 1px solid #10b981 !important;
}
.final-report-box pre {
    background-color: #1e293b !important;
    color: #e2e8f0 !important;
    padding: 16px !important;
    border-radius: 8px !important;
    overflow-x: auto !important;
    margin: 16px 0 !important;
    font-size: 13px !important;
    line-height: 1.5 !important;
}
.final-report-box pre code {
    background-color: transparent !important;
    color: #e2e8f0 !important;
    padding: 0 !important;
    border: none !important;
}
.final-report-box blockquote {
    border-left: 4px solid #10b981 !important;
    padding-left: 16px !important;
    margin: 16px 0 !important;
    color: #064e3b !important;
    font-style: italic !important;
    background-color: #f0fdf4 !important;
    padding: 14px 16px !important;
    border-radius: 0 8px 8px 0 !important;
}
.final-report-box ul, .final-report-box ol {
    margin-left: 24px !important;
    margin-bottom: 16px !important;
}
.final-report-box li {
    margin-bottom: 8px !important;
    line-height: 1.8 !important;
}
.final-report-box strong {
    color: #065f46 !important;
    font-weight: 600 !important;
}
.final-report-box em {
    color: #047857 !important;
}
.final-report-box hr {
    border: none !important;
    border-top: 2px solid #10b981 !important;
    margin: 28px 0 !important;
}
.final-report-box a {
    color: #059669 !important;
    text-decoration: underline !important;
}
.final-report-box a:hover {
    color: #047857 !important;
}
h1 {
    text-align: center;
    color: #1f2937;
}
"""

# Gradio 인터페이스
with gr.Blocks(title="오행·오상 협력 시스템", theme=gr.themes.Soft(), css=css) as app:
    gr.Markdown(
        """
        # 🌟 오행·오상 기반 협력적 LLM 시스템
        
        ### 📋 프로세스: 木→비평→火→비평→土→비평→金→비평→水→비평→木(최종)
        
        | 역할 | 덕목·오행 | 핵심 전문성 |
        |------|-----------|-------------|
        | 🌳 **감독관** | 仁·木 | 비전 제시, 팀 조율, 인재 육성 |
        | 🔥 **전략기획** | 義·火 | 로드맵, 사업 모델, 리스크 분석 |
        | 🏔️ **실행운영** | 信·土 | 일정·예산 관리, 품질 보증 |
        | ⚙️ **아키텍처** | 禮·金 | 시스템 설계, 표준 수립, 품질 검증 |
        | 💧 **R&D** | 智·水 | 기술 조사, 프로토타입, 혁신 도구 |
        | 🔍 **비평자** | 중립 | 논리적·건설적 피드백 |
        """
    )
    
    with gr.Row():
        with gr.Column(scale=3):
            llm_mode = gr.Radio(
                choices=["default", "commercial"],
                value="default",
                label="LLM 모드",
                info="commercial: Gemini 2.5 Pro 사용"
            )
            
            user_input = gr.Textbox(
                label="질문 입력",
                placeholder="예: 지속 가능한 스마트시티 구축 전략은?",
                lines=3
            )
            
            with gr.Row():
                submit_btn = gr.Button("🚀 분석 시작", variant="primary", scale=2)
                clear_btn = gr.Button("🗑️ 초기화", scale=1)
        
        with gr.Column(scale=1):
            status_text = gr.Textbox(
                label="진행 상태",
                interactive=False,
                value="대기 중...",
                lines=3
            )
    
    # 최종 보고서 섹션
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 📊 최종 종합 보고서")
            final_report = gr.Markdown(
                value="*최종 보고서가 여기에 표시됩니다.*",
                elem_classes=["final-report-box"]
            )
    
    # 오행 출력 - 2x3 그리드
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 🌳 木 - 감독관 (仁)")
            wood_output = gr.Textbox(
                label="",
                lines=10,
                max_lines=15,
                interactive=False,
                elem_classes=["wood-box"]
            )
        
        with gr.Column():
            gr.Markdown("### 🔥 火 - 전략·기획 (義)")
            fire_output = gr.Textbox(
                label="",
                lines=10,
                max_lines=15,
                interactive=False,
                elem_classes=["fire-box"]
            )
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 🏔️ 土 - 실행·운영 (信)")
            earth_output = gr.Textbox(
                label="",
                lines=10,
                max_lines=15,
                interactive=False,
                elem_classes=["earth-box"]
            )
        
        with gr.Column():
            gr.Markdown("### ⚙️ 金 - 아키텍처 (禮)")
            metal_output = gr.Textbox(
                label="",
                lines=10,
                max_lines=15,
                interactive=False,
                elem_classes=["metal-box"]
            )
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 💧 水 - R&D (智)")
            water_output = gr.Textbox(
                label="",
                lines=10,
                max_lines=15,
                interactive=False,
                elem_classes=["water-box"]
            )
        
        with gr.Column():
            gr.Markdown("### 🔍 중립적 비평자")
            critic_output = gr.Textbox(
                label="",
                lines=10,
                max_lines=15,
                interactive=False,
                elem_classes=["critic-box"]
            )
    
    # 예제
    gr.Examples(
        examples=[
            "지속 가능한 스마트시티 구축을 위한 종합 전략은?",
            "AI 기반 헬스케어 서비스 플랫폼 개발 계획은?",
            "탄소중립 달성을 위한 기업 전환 로드맵은?",
            "메타버스 교육 플랫폼 구축 방안은?",
            "블록체인 기반 공급망 관리 시스템 도입 전략은?"
        ],
        inputs=user_input,
        label="💡 예제 질문"
    )
    
    # 이벤트 핸들러
    submit_btn.click(
        fn=process_wuxing_query,
        inputs=[user_input, llm_mode],
        outputs=[wood_output, fire_output, earth_output, metal_output, water_output, critic_output, final_report, status_text]
    ).then(
        fn=lambda: "",
        outputs=[user_input]
    )
    
    user_input.submit(
        fn=process_wuxing_query,
        inputs=[user_input, llm_mode],
        outputs=[wood_output, fire_output, earth_output, metal_output, water_output, critic_output, final_report, status_text]
    ).then(
        fn=lambda: "",
        outputs=[user_input]
    )
    
    clear_btn.click(
        fn=clear_wuxing,
        outputs=[wood_output, fire_output, earth_output, metal_output, water_output, critic_output, final_report, status_text]
    )

if __name__ == "__main__":
    app.queue()
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True,
        show_error=True
    )