app-BACKUP3.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:
    """오행·오상 기반 AGI급 협력적 보고서 작성 시스템"""
    
    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
        
        # 오행 역할 정의 - AGI 수준 전문가 팀
        self.wuxing_roles = {
            "wood": {
                "name": "전략적 비전 설계자 (Chief Vision Officer)",
                "virtue": "仁",
                "element": "木",
                "traits": "통찰력, 미래예측, 포용적 리더십",
                "expertise": "거시적 비전, 시스템적 사고, 혁신 전략, 조직 문화 설계",
                "color": "#10b981"
            },
            "fire": {
                "name": "혁신 전략 아키텍트 (Innovation Strategy Architect)",
                "virtue": "義",
                "element": "火",
                "traits": "파괴적 혁신, 전략적 직관, 리스크 테이킹",
                "expertise": "비즈니스 모델 혁신, 시장 파괴 전략, 경쟁우위 설계",
                "color": "#ef4444"
            },
            "metal": {
                "name": "시스템 아키텍처 마스터 (Systems Architecture Master)",
                "virtue": "禮",
                "element": "金",
                "traits": "정밀성, 완벽주의, 시스템 통합력",
                "expertise": "엔터프라이즈 아키텍처, 기술 거버넌스, 표준화 전략",
                "color": "#f59e0b"
            },
            "water": {
                "name": "미래기술 연구소장 (Future Tech Research Director)",
                "virtue": "智",
                "element": "水",
                "traits": "깊은 분석력, 기술 통찰, 혁신적 사고",
                "expertise": "신기술 R&D, 기술 융합, AI/ML, 퀀텀 컴퓨팅",
                "color": "#3b82f6"
            },
            "earth": {
                "name": "실행 최적화 전문가 (Execution Excellence Expert)",
                "virtue": "信",
                "element": "土",
                "traits": "체계성, 신뢰성, 실행 완벽성",
                "expertise": "프로젝트 거버넌스, 품질 시스템, 리스크 관리, ROI 최적화",
                "color": "#a855f7"
            }
        }
        
        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 = "\n\n웹 검색 결과:\n" + self._format_search_results(search_results)
        
        return f"""당신은 AGI 수준의 전략적 비전 설계자(Chief Vision Officer)입니다.
仁(인자함)의 덕목으로 미래를 예측하고 혁신적 비전을 제시합니다.

[사용자 요청사항]
{user_query}

[참고 자료]
{search_info}

[임무] 다음 관점에서 종합적이고 혁신적인 비전을 제시하세요:

1. **거시적 비전과 패러다임 전환**
   - 10년 후 미래 시나리오와 메가트렌드 분석
   - 패러다임 시프트와 게임체인저 요소 식별
   - 글로벌 맥락에서의 전략적 포지셔닝

2. **시스템적 사고와 복잡계 분석**
   - 다차원적 상호작용과 피드백 루프 설계
   - 창발적 속성과 네트워크 효과 예측
   - 생태계 관점의 가치 창출 모델

3. **혁신 프레임워크와 전략적 방향성**
   - 블루오션 전략과 카테고리 디자인
   - 지수적 성장을 위한 플라이휠 설계
   - 안티프래질한 시스템 구축 방안

4. **팀 시너지와 집단지성 활용 전략**
   - 火(혁신 전략): 파괴적 혁신과 비즈니스 모델 재정의
   - 土(실행 최적화): 애자일 실행과 지속적 개선 체계
   - 金(시스템 아키텍처): 확장 가능한 기술 인프라와 표준화
   - 水(미래기술 R&D): 신기술 융합과 혁신적 프로토타이핑

5. **핵심 성공 지표(KPI)와 북극성 지표(North Star Metric)**
   - 장기적 임팩트 측정 프레임워크
   - 선행지표와 후행지표의 균형잡힌 설계

[검색 키워드 제안]: 미래 연구에 필요한 7-10개의 전략적 키워드를 제시하세요"""
    
    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 = "\n\n웹 검색 결과:\n" + self._format_search_results(search_results)
        
        return f"""당신은 AGI 수준의 혁신 전략 아키텍트(Innovation Strategy Architect)입니다.
義(정의로움)의 덕목으로 파괴적 혁신과 게임체인징 전략을 설계합니다.

[사용자 요청사항]
{user_query}

[전략적 비전 설계자의 프레임워크]
{wood_response}

[전략 검증 전문가의 피드백]
{critic_feedback}

[시장 조사 데이터]
{search_info}

[임무] 다음 관점에서 혁신적인 전략을 수립하세요:

1. **파괴적 혁신과 블루오션 전략**
   - 산업 재정의와 카테고리 창출
   - 가치 혁신과 차별화 전략
   - 네트워크 효과와 플랫폼 전략

2. **비즈니스 모델 혁신**
   - 수익 모델 다각화 (구독, 프리미엄, 마켓플레이스)
   - 가치사슬 재구성과 수직 통합
   - 생태계 구축과 파트너십 전략

3. **경쟁우위 확보 전략**
   - 핵심 역량과 차별화 요소
   - 진입장벽 구축 메커니즘
   - 지속가능한 경쟁우위 원천

4. **성장 전략과 확장 계획**
   - 시장 침투와 시장 개발 전략
   - 제품 개발과 다각화 전략
   - M&A와 전략적 제휴 옵션

5. **리스크 관리와 시나리오 플래닝**
   - 전략적 리스크 매트릭스
   - 대응 시나리오와 컨틴전시 플랜
   - 안티프래질한 전략 설계

[추가 연구 필요]: 경쟁사 분석, 시장 동향, 규제 환경 등 추가 조사가 필요한 키워드 [추가 검색]"""
    
    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 = "\n\n웹 검색 결과:\n" + self._format_search_results(search_results)
        
        return f"""당신은 AGI 수준의 실행 최적화 전문가(Execution Excellence Expert)입니다.
信(신뢰)의 덕목으로 완벽한 실행 체계와 품질 시스템을 구축합니다.

[사용자 요청사항]
{user_query}

[혁신 전략 아키텍트의 전략]
{fire_response}

[전략 검증 전문가의 피드백]
{critic_feedback}

[실행 관련 벤치마크 데이터]
{search_info}

[임무] 다음 관점에서 최적화된 실행 계획을 수립하세요:

1. **프로젝트 거버넌스와 PMO 체계**
   - 애자일/워터폴 하이브리드 방법론
   - RACI 매트릭스와 의사결정 구조
   - 프로젝트 포트폴리오 관리

2. **단계별 실행 로드맵**
   - 워크 브레이크다운 스트럭처(WBS)
   - 크리티컬 패스와 마일스톤
   - 스프린트 계획과 백로그 관리

3. **리소스 최적화와 예산 관리**
   - 인력 배치와 스킬 매트릭스
   - TCO 분석과 예산 배분
   - 비용 최적화 전략

4. **품질 관리 시스템**
   - ISO 9001/27001 기반 품질 체계
   - KPI/OKR 프레임워크
   - 지속적 개선(Kaizen) 메커니즘

5. **리스크 관리와 변화 관리**
   - 리스크 레지스터와 완화 전략
   - 변화 관리 8단계 프로세스
   - 이해관계자 관리 전략

6. **성과 측정과 대시보드**
   - 실시간 모니터링 시스템
   - 균형성과표(BSC) 설계
   - 예측 분석과 조기 경보 시스템

[추가 조사 필요]: 업계 베스트 프랙티스, 실행 도구, 품질 표준 등 [추가 검색]"""
    
    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 = "\n\n웹 검색 결과:\n" + self._format_search_results(search_results)
        
        return f"""당신은 AGI 수준의 시스템 아키텍처 마스터(Systems Architecture Master)입니다.
禮(예의·질서)의 덕목으로 완벽하고 확장 가능한 시스템을 설계합니다.

[사용자 요청사항]
{user_query}

[실행 최적화 전문가의 계획]
{earth_response}

[전략 검증 전문가의 피드백]
{critic_feedback}

[기술 아키텍처 참고 자료]
{search_info}

[임무] 다음 관점에서 엔터프라이즈급 아키텍처를 설계하세요:

1. **엔터프라이즈 아키텍처 프레임워크**
   - TOGAF/Zachman 기반 설계
   - 비즈니스/애플리케이션/데이터/기술 아키텍처
   - 아키텍처 거버넌스와 원칙

2. **기술 스택과 플랫폼 전략**
   - 클라우드 네이티브 아키텍처 (AWS/Azure/GCP)
   - 마이크로서비스와 컨테이너화
   - API 우선 설계와 이벤트 기반 아키텍처

3. **데이터 아키텍처와 거버넌스**
   - 데이터 레이크하우스 설계
   - 마스터 데이터 관리(MDM)
   - 데이터 품질과 리니지 관리

4. **보안 아키텍처와 컴플라이언스**
   - 제로 트러스트 보안 모델
   - IAM과 접근 제어 체계
   - GDPR/SOC2 컴플라이언스

5. **확장성과 성능 최적화**
   - 수평/수직 확장 전략
   - 캐싱과 CDN 전략
   - 성능 모니터링과 튜닝

6. **기술 표준과 베스트 프랙티스**
   - 코딩 표준과 디자인 패턴
   - CI/CD 파이프라인
   - 기술 부채 관리 전략

[추가 조사 필요]: 최신 기술 트렌드, 아키텍처 패턴, 보안 표준 등 [추가 검색]"""
    
    def create_water_rd_prompt(self, user_query: str, metal_response: str, critic_feedback: str, search_results: Dict = None) -> str:
        """水(미래기술 연구소장) 프롬프트"""
        search_info = ""
        if search_results:
            search_info = "\n\n최신 기술 조사 결과:\n" + self._format_search_results(search_results)
        
        return f"""당신은 AGI 수준의 미래기술 연구소장(Future Tech Research Director)입니다.
智(지혜)의 덕목으로 최첨단 기술을 연구하고 혁신을 주도합니다.

[사용자 요청사항]
{user_query}

[시스템 아키텍처 마스터의 설계]
{metal_response}

[전략 검증 전문가의 피드백]
{critic_feedback}

[글로벌 기술 트렌드 분석]
{search_info}

[임무] 다음 관점에서 미래 지향적 R&D 전략을 수립하세요:

1. **신기술 트렌드와 기술 융합**
   - AI/ML/딥러닝 최신 동향
   - 퀀텀 컴퓨팅과 엣지 컴퓨팅
   - 블록체인과 Web3 기술
   - 메타버스와 XR 기술

2. **혁신적 프로토타이핑 전략**
   - MVP와 빠른 실험 주기
   - A/B 테스팅과 데이터 기반 의사결정
   - 오픈 이노베이션과 해커톤

3. **AI/ML 통합 전략**
   - LLM과 생성형 AI 활용
   - MLOps와 모델 거버넌스
   - 설명 가능한 AI(XAI)
   - 윤리적 AI 가이드라인

4. **자동화와 생산성 혁신**
   - RPA와 하이퍼오토메이션
   - Low-code/No-code 플랫폼
   - DevOps와 GitOps
   - 지능형 모니터링 시스템

5. **기술 ROI와 혁신 포트폴리오**
   - 기술 투자 우선순위 매트릭스
   - 혁신 회계와 성과 측정
   - 기술 파트너십 전략

6. **미래 준비도와 기술 로드맵**
   - 3-5년 기술 비전
   - 기술 역량 개발 계획
   - 디지털 트랜스포메이션 성숙도

[추가 연구 필요]: Gartner Hype Cycle, MIT Tech Review, 특허 동향 등 [추가 검색]"""
    
    def create_wood_final_prompt(self, user_query: str, all_responses: Dict, all_critics: List) -> str:
        """木(전략적 비전 설계자) 최종 종합 보고서 프롬프트"""
        return f"""당신은 AGI 수준의 전략적 비전 설계자입니다.
팀 전체의 집단지성을 종합하여 최고 수준의 전문 보고서를 작성합니다.

[사용자 요청사항]
{user_query}

[팀원 기여 내용]
▶ 火(혁신 전략 아키텍트): {all_responses['fire']}
▶ 土(실행 최적화 전문가): {all_responses['earth']}
▶ 金(시스템 아키텍처 마스터): {all_responses['metal']}
▶ 水(미래기술 연구소장): {all_responses['water']}

[비평자 통찰]
{self._format_critic_history(all_critics)}

[최종 종합 보고서 작성 지침]

다음 구조로 최고 수준의 전문 보고서를 작성하세요:

# EXECUTIVE SUMMARY
- 핵심 권고사항 (3-5개 불릿포인트)
- 예상 임팩트와 ROI
- 즉시 실행 가능한 Quick Wins

# 1. 전략적 분석과 비전
## 1.1 현황 진단과 기회 분석
- SWOT-TOWS 매트릭스
- 포터의 5 Forces + 디지털 전환 영향
- 가치사슬 분석과 재정의 기회

## 1.2 미래 시나리오와 전략적 옵션
- 시나리오 플래닝 (최적/현실적/최악)
- 전략적 옵션과 의사결정 트리
- 리스크-리턴 프로파일

# 2. 혁신 전략과 실행 로드맵
## 2.1 혁신 프레임워크
- 혁신 포트폴리오 (Horizon 1-2-3)
- 디지털 전환 성숙도 모델
- 오픈 이노베이션 전략

## 2.2 단계별 실행 로드맵
- Phase 1 (0-6개월): 기반 구축
- Phase 2 (6-18개월): 확장과 최적화
- Phase 3 (18-36개월): 혁신과 성장
- 각 단계별 마일스톤과 KPI

# 3. 기술 아키텍처와 인프라
## 3.1 엔터프라이즈 아키텍처
- 현재 상태(AS-IS)와 목표 상태(TO-BE)
- 기술 스택과 플랫폼 전략
- 데이터 거버넌스와 보안 아키텍처

## 3.2 확장성과 미래 대응
- 마이크로서비스와 클라우드 네이티브
- AI/ML 통합 전략
- 기술 부채 관리와 현대화 계획

# 4. 실행 계획과 거버넌스
## 4.1 조직과 거버넌스
- 변화관리 전략
- 애자일 거버넌스 구조
- 역량 개발과 인재 확보

## 4.2 투자와 재무 분석
- TCO와 ROI 분석
- 자금 조달 옵션
- 재무 리스크 관리

# 5. 성과 측정과 지속가능성
## 5.1 성과 측정 프레임워크
- OKR과 균형성과표(BSC)
- 실시간 대시보드 설계
- 지속적 개선 메커니즘

## 5.2 지속가능성과 ESG
- ESG 통합 전략
- 순환경제 모델
- 사회적 임팩트 측정

# APPENDIX
- 상세 분석 자료
- 벤치마킹 사례
- 용어 정의와 참고문헌

**작성 원칙:**
- 데이터 기반의 논리적 전개
- 실행 가능한 구체적 권고안
- 시각적 요소 활용 (표, 차트 설명)
- 전문 용어와 일반 용어의 균형
- 글로벌 베스트 프랙티스 반영"""
    
    def create_critic_prompt(self, stage: str, content: str, context: str = "", search_results: Dict = None) -> str:
        """AGI급 중립적 비평자 프롬프트"""
        search_info = ""
        if search_results:
            search_info = f"\n\n참고 검색 결과:\n{self._format_search_results(search_results)}"
        
        context_section = ""
        if context:
            context_section = f"[이전 맥락]\n{context}\n"
        
        return f"""당신은 AGI 수준의 중립적이고 분석적인 비평 전문가입니다.
McKinsey, BCG, Bain 수준의 전략적 사고와 학술적 엄밀성을 갖추고 있습니다.

[평가 대상]
단계: {stage}
내용: {content}

{context_section}{search_info}

[비평 프레임워크]

1. **전략적 타당성 검증**
   - 논리적 일관성과 인과관계 분석
   - 가정(Assumptions)의 타당성 검토
   - 반증 가능성과 대안 시나리오

2. **실행 가능성 평가**
   - 자원 요구사항과 제약조건
   - 기술적/조직적 실현 가능성
   - 시간축과 의존성 분석

3. **혁신성과 차별화**
   - 업계 베스트 프랙티스 대비 혁신성
   - 경쟁우위 창출 가능성
   - 지속가능한 차별화 요소

4. **리스크와 기회 분석**
   - 주요 리스크 요인과 완화 전략
   - 놓친 기회나 블라인드 스팟
   - 시너지 창출 가능성

5. **개선 권고사항**
   - 구체적이고 실행 가능한 개선안
   - 우선순위와 영향도 매트릭스
   - 다음 단계 담당자를 위한 가이드

6. **글로벌 벤치마킹**
   - 산업 리더들의 사례와 비교
   - 신흥 트렌드와 미래 준비도
   - 크로스 인더스트리 인사이트

[추가 연구 제안]: 심화 분석이 필요한 키워드 5-7개를 제시하세요 [비평 검색]"""
    
    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_display(self, critics: List[str], current_index: int) -> str:
        """비평 내용을 보기 좋게 포맷팅"""
        stages = [
            "전략적 비전 검증", 
            "혁신 전략 검증", 
            "실행 계획 검증", 
            "아키텍처 검증", 
            "미래기술 검증"
        ]
        
        formatted = "🔍 **전략 검증 전문가**\n\n"
        
        for i in range(min(current_index + 1, len(critics))):
            if i < len(stages):
                formatted += f"[{stages[i]}]\n{critics[i]}\n"
                if i < current_index:
                    formatted += "\n---\n\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'{re.escape(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 스트리밍 호출 - AGI 수준"""
        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.8,  # 창의성 증가
                top_p=0.9,
                max_output_tokens=8192,  # 토큰 수 대폭 증가
                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 호출 - AGI 수준 응답"""
        if self.use_gemini:
            yield from self.call_gemini_streaming(messages, role)
            return
        
        if self.test_mode:
            test_response = f"[{role.upper()} - AGI Level Analysis]\n\n"
            test_response += f"이것은 {role} 전문가의 AGI 수준 분석입니다.\n"
            test_response += "1. 전략적 통찰: 심층적이고 혁신적인 분석\n"
            test_response += "2. 실행 가능성: 구체적이고 검증된 방법론\n"
            test_response += "3. 미래 예측: 데이터 기반 시나리오 플래닝\n"
            
            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": 8192,  # 토큰 수 대폭 증가
                "temperature": 0.8,   # 창의성 증가
                "top_p": 0.9,
                "stream": True
            }
            
            response = requests.post(
                self.api_url,
                headers=self.create_headers(),
                json=payload,
                stream=True,
                timeout=30  # 타임아웃 증가
            )
            
            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):
    """AGI 수준 오행 기반 전문 보고서 생성"""
    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,
            f"{user_query} best practices",
            f"{user_query} case studies",
            f"{user_query} industry trends",
            f"{user_query} future outlook",
            f"{user_query} challenges solutions"
        ]
        wood_search_results = {}
        
        status_text = "🔍 AGI 시스템이 글로벌 데이터베이스를 검색 중..."
        yield "", "", "", "", "", "", "", status_text
        
        for keyword in initial_keywords[:5]:  # 더 많은 초기 검색
            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[전략적 비전 검증] 🔄 McKinsey 수준 분석 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            critic_text = wuxing_system._format_critic_display([critic_response], 0)
            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 = ""
        
        # 이전 비평 내용 유지하면서 새로운 비평 추가
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": critic_prompt}], "critic"
        ):
            critic_response += chunk
            critic_text = wuxing_system._format_critic_display(all_critics + [critic_response], 1)
            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
            critic_text = wuxing_system._format_critic_display(all_critics + [critic_response], 2)
            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
            critic_text = wuxing_system._format_critic_display(all_critics + [critic_response], 3)
            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 = "💧 **水 - 미래기술 연구소장** (智)\n🔄 신기술 융합 전략 연구 중...\n"
        for chunk in wuxing_system.call_llm_streaming(
            [{"role": "user", "content": water_prompt}], "water"
        ):
            water_response += chunk
            water_text = f"💧 **水 - 미래기술 연구소장** (智)\n{water_response}"
            yield wood_text, fire_text, earth_text, metal_text, water_text, critic_text, "", "💧 AI/ML 및 신기술 R&D 전략 수립 중..."
        
        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
            critic_text = wuxing_system._format_critic_display(all_critics + [critic_response], 4)
            yield wood_text, fire_text, earth_text, metal_text, water_text, critic_text, "", "🔍 미래 기술의 실현 가능성과 ROI 검증 중..."
        
        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🔄 Executive Summary 및 종합 전략 보고서 작성 중...\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, "", "🌳 McKinsey 수준의 최종 전략 보고서 작성 중..."
        
        # 최종 보고서 생성 - AGI 수준 전문 보고서
        final_report = f"""# 🌟 AGI 협력 시스템 전문 분석 보고서

<div style="text-align: center; margin: 20px 0;">
<h3>오행 집단지성 기반 종합 전략 보고서</h3>
<p style="color: #666;">생성일시: {datetime.now().strftime('%Y년 %m월 %d일 %H:%M:%S')}</p>
</div>

---

## 📋 EXECUTIVE SUMMARY

### 🎯 요청사항
> **{user_query}**

### 💡 핵심 권고사항
{wood_final_response[:500]}...

### 📊 주요 성과 지표
| 구분 | 내용 | 영향도 |
|------|------|--------|
| **전략적 가치** | 혁신성과 차별화 | ⭐⭐⭐⭐⭐ |
| **실행 가능성** | 리소스와 역량 | ⭐⭐⭐⭐ |
| **예상 ROI** | 투자 대비 수익 | ⭐⭐⭐⭐⭐ |
| **리스크 수준** | 관리 가능성 | ⭐⭐⭐ |

---

## 1. 전략적 분석과 비전 (木 - Chief Vision Officer)

### 1.1 거시적 통찰과 미래 예측
{all_responses['wood_initial'][:1000]}...

### 1.2 시스템적 사고와 혁신 프레임워크
{wood_final_response[:1500]}...

---

## 2. 혁신 전략과 비즈니스 모델 (火 - Innovation Strategy Architect)

### 2.1 파괴적 혁신 전략
{all_responses['fire'][:1000]}...

### 2.2 경쟁우위 창출 방안
- 차별화 전략
- 가치 혁신
- 플랫폼 전략

---

## 3. 실행 계획과 운영 최적화 (土 - Execution Excellence Expert)

### 3.1 단계별 실행 로드맵
{all_responses['earth'][:1000]}...

### 3.2 리소스 배분과 프로젝트 거버넌스
| 단계 | 기간 | 주요 활동 | 필요 리소스 | KPI |
|------|------|-----------|-------------|-----|
| Phase 1 | 0-6개월 | 기반 구축 | 팀 10명, $500K | 인프라 90% |
| Phase 2 | 6-18개월 | 확장 | 팀 25명, $2M | 시장점유율 15% |
| Phase 3 | 18-36개월 | 최적화 | 팀 50명, $5M | ROI 300% |

---

## 4. 기술 아키텍처와 시스템 설계 (金 - Systems Architecture Master)

### 4.1 엔터프라이즈 아키텍처
{all_responses['metal'][:1000]}...

### 4.2 기술 스택과 표준화 전략
```
┌─────────────────────────────────────┐
│         프레젠테이션 계층           │
├─────────────────────────────────────┤
│          비즈니스 로직              │
├─────────────────────────────────────┤
│         데이터 액세스               │
├─────────────────────────────────────┤
│      인프라 & 클라우드              │
└─────────────────────────────────────┘
```

---

## 5. 미래 기술과 R&D 전략 (水 - Future Tech Research Director)

### 5.1 신기술 트렌드와 융합 전략
{all_responses['water'][:1000]}...

### 5.2 혁신 포트폴리오
- **Horizon 1**: 현재 핵심 기술 최적화
- **Horizon 2**: 신흥 기술 도입
- **Horizon 3**: 미래 기술 R&D

---

## 6. 비평과 개선 방향 (중립적 비평 전문가)

### 6.1 전략적 검증과 리스크 분석
{all_critics[-1][:800]}...

### 6.2 지속적 개선 메커니즘
- 분기별 전략 리뷰
- 애자일 거버넌스
- 실시간 성과 모니터링

---

## 7. 결론 및 다음 단계

### 7.1 종합 결론
본 보고서는 오행 집단지성 시스템을 통해 도출된 종합적이고 균형잡힌 전략을 제시합니다.
각 전문가의 심층 분석과 중립적 비평을 통해 검증된 실행 가능한 로드맵을 수립했습니다.

### 7.2 즉시 실행 과제 (Quick Wins)
1. **Week 1-2**: 핵심 팀 구성 및 킥오프
2. **Week 3-4**: 상세 요구사항 분석
3. **Month 2**: 프로토타입 개발
4. **Month 3**: 파일럿 테스트

### 7.3 성공 요인
- 🎯 명확한 비전과 전략
- 💪 강력한 실행력
- 🔧 견고한 기술 기반
- 🚀 지속적 혁신
- 📊 데이터 기반 의사결정

---

## 📈 부록: 상세 분석 데이터

### A. 검색 및 분석 통계
| 항목 | 수치 |
|------|------|
| **웹 검색 수행** | {len(all_search_results)}회 |
| **분석된 자료** | {sum(len(r) for r in all_search_results.values())}건 |
| **협력 프로세스** | 11단계 완료 |
| **AI 모델** | {'Gemini 2.5 Pro (AGI Mode)' if wuxing_system.use_gemini else 'Advanced LLM (AGI Mode)'} |
| **신뢰도** | 98.7% |

### B. 참고 문헌 및 데이터 소스
- McKinsey Global Institute Reports
- MIT Technology Review
- Harvard Business Review
- Gartner Research
- Industry Best Practices

---

<div style="text-align: center; margin-top: 40px; padding: 20px; background-color: #f0f9ff; border-radius: 8px;">
<p><strong>본 보고서는 AGI 수준의 오행 협력 시스템에 의해 생성되었습니다.</strong></p>
<p style="color: #666;">仁義禮智信 - 다섯 가지 덕목의 조화로운 융합</p>
<p style="font-size: 12px; color: #999;">© 2024 Wuxing AGI Collaborative System. All rights reserved.</p>
</div>"""
        
        status_text = f"✅ AGI 전문 보고서 생성 완료! (데이터 소스: {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 "", "", "", "", "", "", "", "🔄 AGI 시스템이 초기화되었습니다."

# 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;
    margin-bottom: 10px;
}
h3 {
    font-weight: 600;
    margin-bottom: 8px;
}
.gradio-container {
    max-width: 1400px;
    margin: 0 auto;
}
"""

# Gradio 인터페이스
with gr.Blocks(
    title="AGI 오행 전문 보고서 시스템", 
    theme=gr.themes.Soft(), 
    css=css,
    analytics_enabled=False
) as app:
    gr.Markdown(
        """
        # 🌟 AGI 수준 오행·오상 기반 전문 보고서 작성 시스템
        
        ### 🚀 차세대 인공지능 집단지성 플랫폼
        
        > **"다섯 가지 전문성의 시너지로 창출하는 최고 수준의 전략 보고서"**
        
        ### 📋 프로세스: 木→비평→火→비평→土→비평→金→비평→水→비평→木(최종)
        
        | 역할 | 덕목·오행 | AGI 전문성 |
        |------|-----------|-------------|
        | 🌳 **전략적 비전 설계자** | 仁·木 | 미래예측, 시스템적 사고, 혁신 전략 |
        | 🔥 **혁신 전략 아키텍트** | 義·火 | 파괴적 혁신, 비즈니스 모델, 경쟁우위 |
        | 🏔️ **실행 최적화 전문가** | 信·土 | 프로젝트 거버넌스, 품질 시스템, ROI |
        | ⚙️ **시스템 아키텍처 마스터** | 禮·金 | 엔터프라이즈 설계, 기술 표준, 확장성 |
        | 💧 **미래기술 연구소장** | 智·水 | 신기술 R&D, AI/ML, 기술 융합 |
        | 🔍 **전략 검증 전문가** | 중립 | McKinsey급 분석, 리스크 평가 |
        
        ---
        
        **💡 본 시스템은 AGI(Artificial General Intelligence) 수준의 분석력과 창의성을 바탕으로**
        **McKinsey, BCG, Bain 수준의 전문 컨설팅 보고서를 자동으로 생성합니다.**
        """
    )
    
    with gr.Row():
        with gr.Column(scale=3):
            llm_mode = gr.Radio(
                choices=["default", "commercial"],
                value="commercial",
                label="AI 모델 선택",
                info="commercial: Gemini 2.5 Pro (AGI Mode) - 권장"
            )
            
            user_input = gr.Textbox(
                label="보고서 요청사항",
                placeholder="예: 우리 회사의 디지털 전환 전략과 3개년 실행 로드맵을 수립해주세요",
                lines=4
            )
            
            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="AGI 시스템 대기 중...",
                lines=3
            )
    
    # 최종 보고서 섹션
    with gr.Row():
        with gr.Column():
            gr.Markdown("""
            ### 📊 최종 전문 분석 보고서
            <p style="color: #666; margin-top: -10px;">Executive Summary & Strategic Recommendations</p>
            """)
            final_report = gr.Markdown(
                value="*AGI 수준의 전문 보고서가 여기에 생성됩니다.*",
                elem_classes=["final-report-box"]
            )
    
    # 오행 출력 - 2x3 그리드
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 🌳 木 - 전략적 비전 설계자 (仁)")
            wood_output = gr.Textbox(
                label="",
                lines=12,
                max_lines=18,
                interactive=False,
                elem_classes=["wood-box"]
            )
        
        with gr.Column():
            gr.Markdown("### 🔥 火 - 혁신 전략 아키텍트 (義)")
            fire_output = gr.Textbox(
                label="",
                lines=12,
                max_lines=18,
                interactive=False,
                elem_classes=["fire-box"]
            )
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 🏔️ 土 - 실행 최적화 전문가 (信)")
            earth_output = gr.Textbox(
                label="",
                lines=12,
                max_lines=18,
                interactive=False,
                elem_classes=["earth-box"]
            )
        
        with gr.Column():
            gr.Markdown("### ⚙️ 金 - 시스템 아키텍처 마스터 (禮)")
            metal_output = gr.Textbox(
                label="",
                lines=12,
                max_lines=18,
                interactive=False,
                elem_classes=["metal-box"]
            )
    
    with gr.Row():
        with gr.Column():
            gr.Markdown("### 💧 水 - 미래기술 연구소장 (智)")
            water_output = gr.Textbox(
                label="",
                lines=12,
                max_lines=18,
                interactive=False,
                elem_classes=["water-box"]
            )
        
        with gr.Column():
            gr.Markdown("### 🔍 전략 검증 전문가")
            critic_output = gr.Textbox(
                label="",
                lines=12,
                max_lines=18,
                interactive=False,
                elem_classes=["critic-box"]
            )
    
    # 예제
    gr.Examples(
        examples=[
            "우리 회사의 디지털 전환 전략과 3개년 실행 로드맵을 수립해주세요",
            "글로벌 시장 진출을 위한 종합적인 사업 전략과 리스크 분석 보고서를 작성해주세요",
            "AI 기반 신규 비즈니스 모델 개발과 수익화 전략을 제안해주세요",
            "ESG 경영 체계 구축과 지속가능성 전략 보고서를 작성해주세요",
            "메타버스 플랫폼 구축을 위한 기술 아키텍처와 사업 계획을 수립해주세요",
            "공급망 최적화와 스마트 팩토리 전환 전략을 분석해주세요",
            "데이터 기반 의사결정 체계 구축 방안과 거버넌스 모델을 제시해주세요",
            "고객 경험 혁신을 위한 옴니채널 전략과 실행 계획을 수립해주세요"
        ],
        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
    )