app.py

"""
THEORIA™ - Theory-driven Naming AI
===================================
특별한 15개의 이론으로 생성하는 네이밍 AI
Theory-driven Naming AI with 15 Specialized Theories
-----------------------------------
"""

import os
import json
import gradio as gr
import openai
from openai import OpenAI
from datetime import datetime
from typing import List, Dict, Tuple, Optional
import random
import time

# OpenAI 클라이언트
if not os.getenv("OPENAI_API_KEY"):
    raise EnvironmentError("OPENAI_API_KEY 환경 변수를 설정하세요.")

client = OpenAI()

# 언어별 텍스트 정의
TEXTS = {
    "en": {
        "title": "THEORIA™",
        "subtitle": "Theory-driven Naming AI with 15 Specialized Theories",
        "description": "Generate innovative brand names using 15 cognitive and creative theories",
        "industry_label": "🏭 Industry",
        "industry_placeholder": "e.g., cafe, fitness, education, beauty...",
        "keywords_label": "🔑 Keywords",
        "keywords_placeholder": "premium, comfortable, urban, eco-friendly...",
        "keywords_info": "Core values or characteristics the brand should embody",
        "generate_button": "Generate with {theory}",
        "language_label": "🌐 Language",
        "progress_message": "Generating innovative names using {theory}...",
        "error_message": "❌ Error in {theory}: {error}",
        "input_required": "⚠️ Please enter both industry and keywords.",
        "evaluation_labels": {
            "creativity": "Creativity",
            "memorability": "Memorability", 
            "relevance": "Relevance"
        }
    },
    "ko": {
        "title": "THEORIA™",
        "subtitle": "특별한 15개의 이론으로 생성하는 네이밍 AI",
        "description": "15가지 인지 및 창의 이론을 활용한 혁신적인 브랜드명 생성",
        "industry_label": "🏭 업종",
        "industry_placeholder": "예: 카페, 피트니스, 교육, 뷰티...",
        "keywords_label": "🔑 핵심 키워드",
        "keywords_placeholder": "프리미엄, 편안한, 도시적인, 친환경...",
        "keywords_info": "브랜드가 담아야 할 핵심 가치나 특징들",
        "generate_button": "{theory}로 생성",
        "language_label": "🌐 언어",
        "progress_message": "{theory}를 활용해 혁신적인 이름을 생성하고 있습니다...",
        "error_message": "❌ {theory} 오류: {error}",
        "input_required": "⚠️ 업종과 키워드를 모두 입력해주세요.",
        "evaluation_labels": {
            "creativity": "창의성",
            "memorability": "기억성",
            "relevance": "관련성"
        }
    }
}

# 이론별 설명 (영어/한국어)
THEORY_DESCRIPTIONS = {
    "en": {
        "square": "Creates a semantic square structure where 4 words are connected by meaningful relationships. Hidden diagonal connections create 'aha!' moments.",
        "blending": "Blends two or more concepts to create new meaning. Like Netflix (Net+Flix), it births innovative concepts.",
        "sound": "Utilizes associations between phonemes and meaning. 'i,e' convey lightness and speed, 'o,u' convey weight and slowness.",
        "linguistic": "Creates global brands considering linguistic thought differences. Reflects cultural nuances and localization strategies.",
        "archetype": "Leverages Jung's 12 universal archetypes. Creates unconscious emotional connections like Hero (Nike) or Creator (Apple).",
        "jobs": "Focuses on the 'job' customers are trying to get done. Integrates functional, emotional, and social needs.",
        "scamper": "Uses 7 creative techniques (Substitute, Combine, Adapt, Modify, Put to other use, Eliminate, Reverse) for innovation.",
        "design": "Pursues human-centered innovation. Finds the intersection of desirability (human), feasibility (technical), and viability (business).",
        "biomimicry": "Creates nature-inspired brands. Applies 3.8 billion years of evolutionary wisdom to branding.",
        "cognitive": "Creates brands that minimize cognitive processing. Uses 1-3 syllables for instant recognition and recall.",
        "vonrestorff": "Creates unique, memorable brands. Intentionally violates category conventions for 30x better recall.",
        "network": "Creates brands that maximize network value. Designs structures where value increases with more users.",
        "memetics": "Creates culturally replicable and evolving brands. Embeds viral elements that spread naturally like memes.",
        "color": "Creates brands using color associations and emotions. Applies color psychology: red (passion), blue (trust), green (nature).",
        "gestalt": "Creates brands using perception principles. Designs holistic brand experiences where the whole exceeds the sum of parts."
    },
    "ko": {
        "square": "4개의 단어가 의미적 관계로 연결되어 사각형을 이루는 구조입니다. 대변의 숨겨진 연결이 '아하!' 모먼트를 만듭니다.",
        "blending": "두 개 이상의 개념을 혼합하여 새로운 의미를 창출합니다. Netflix(Net+Flix)처럼 혁신적인 개념을 탄생시킵니다.",
        "sound": "음소와 의미 간의 연관성을 활용합니다. 'i,e'는 가볍고 빠른 느낌, 'o,u'는 무겁고 느린 느낌을 전달합니다.",
        "linguistic": "언어별 사고방식 차이를 고려한 글로벌 브랜드를 만듭니다. 문화적 뉘앙스와 현지화 전략을 반영합니다.",
        "archetype": "Jung의 12가지 보편적 원형을 활용합니다. Hero(Nike), Creator(Apple)처럼 무의식적 감정 연결을 만듭니다.",
        "jobs": "고객이 해결하려는 '일'에 초점을 맞춥니다. 기능적, 감정적, 사회적 차원의 니즈를 통합적으로 해결합니다.",
        "scamper": "7가지 창의적 기법(대체, 결합, 적응, 수정, 용도변경, 제거, 역전)으로 혁신적인 브랜드를 만듭니다.",
        "design": "인간 중심 혁신을 추구합니다. 바람직함(인간), 실현가능성(기술), 생존가능성(비즈니스)의 교집합을 찾습니다.",
        "biomimicry": "자연에서 영감을 받은 브랜드를 만듭니다. 38억년 진화의 지혜를 브랜딩에 적용합니다.",
        "cognitive": "인지 처리를 최소화하는 브랜드를 만듭니다. 1-3음절의 쉬운 발음으로 즉각적 인식과 기억을 돕습니다.",
        "vonrestorff": "독특하고 기억에 남는 브랜드를 만듭니다. 카테고리 관습을 의도적으로 위반하여 30배 더 잘 기억되게 합니다.",
        "network": "네트워크 가치를 극대화하는 브랜드를 만듭니다. 사용자가 많을수록 가치가 증가하는 구조를 설계합니다.",
        "memetics": "문화적으로 복제되고 진화하는 브랜드를 만듭니다. 밈처럼 자연스럽게 퍼져나가는 바이럴 요소를 내재화합니다.",
        "color": "색상 연상과 감정을 활용한 브랜드를 만듭니다. 빨강(열정), 파랑(신뢰), 초록(자연) 등 색상 심리를 적용합니다.",
        "gestalt": "지각 원리를 활용한 브랜드를 만듭니다. 전체가 부분의 합보다 크다는 원칙으로 통합적 브랜드 경험을 설계합니다."
    }
}

# 통일된 기본 프롬프트 템플릿 (영어)
UNIFIED_BASE_PROMPT_EN = """
You are a {theory_name} expert. {theory_description}

Based on the user input (industry/keywords), generate an array in the following unified JSON format:

{{
  "brands": [
    {{
      "core": {{
        "brand_name": "Brand Name",
        "slogan": "Slogan",
        "core_value": "Core Value",
        "target_emotion": "Target Emotion",
        "brand_personality": "Brand Personality"
      }},
      "visual": {{
        "primary_color": "#HEX",
        "color_meaning": "Color Meaning",
        "visual_concept": "Visual Concept",
        "typography_style": "Typography Style"
      }},
      "linguistic": {{
        "pronunciation": "Pronunciation Guide",
        "etymology": "Etymology/Structure",
        "global_adaptability": "Global Adaptability",
        "memorable_factor": "Memorability Factor"
      }},
      "strategic": {{
        "differentiation": "Differentiation Point",
        "market_positioning": "Market Positioning",
        "growth_potential": "Growth Potential",
        "implementation_ease": "Implementation Ease"
      }},
      "theory_specific": {{
        {theory_specific_fields}
      }},
      "evaluation": {{
        "creativity_score": 0-10,
        "memorability_score": 0-10,
        "relevance_score": 0-10,
        "overall_effectiveness": "Overall effectiveness description"
      }}
    }}
  ]
}}

Return valid JSON format and fill all fields.
Include theory-specific characteristics in the theory_specific section while maintaining the unified structure.
All content should be in English.
"""

# 통일된 기본 프롬프트 템플릿 (한국어)
UNIFIED_BASE_PROMPT_KO = """
당신은 {theory_name} 전문가입니다. {theory_description}

사용자 입력(업종/키워드)을 받아 다음과 같은 통일된 JSON 형식의 배열을 생성하세요:

{{
  "brands": [
    {{
      "core": {{
        "brand_name": "한글 브랜드명",
        "slogan": "슬로건",
        "core_value": "핵심 가치",
        "target_emotion": "목표 감정",
        "brand_personality": "브랜드 성격"
      }},
      "visual": {{
        "primary_color": "#HEX코드",
        "color_meaning": "색상 의미",
        "visual_concept": "시각적 컨셉",
        "typography_style": "타이포그래피 스타일"
      }},
      "linguistic": {{
        "pronunciation": "한글 발음 가이드",
        "etymology": "어원/구성 (영어명 포함)",
        "global_adaptability": "영어 브랜드명 (예: Mother's Garden)",
        "memorable_factor": "기억 용이성 요소"
      }},
      "strategic": {{
        "differentiation": "차별화 포인트",
        "market_positioning": "시장 포지셔닝",
        "growth_potential": "성장 잠재력",
        "implementation_ease": "실행 용이성"
      }},
      "theory_specific": {{
        {theory_specific_fields}
      }},
      "evaluation": {{
        "creativity_score": 0-10,
        "memorability_score": 0-10,
        "relevance_score": 0-10,
        "overall_effectiveness": "전체적인 효과성 설명"
      }}
    }}
  ]
}}

중요: 
1. brand_name은 반드시 한글로 작성하세요.
2. linguistic > global_adaptability에는 반드시 영어 브랜드명을 포함하세요.
3. 영어명은 한글명의 의미를 잘 전달하되, 글로벌하게 사용 가능한 이름으로 만드세요.
4. 모든 필드를 한국어로 작성하되, 영어 브랜드명만 영어로 표기하세요.
"""

# 이론별 특수 필드 정의 (영어)
THEORY_SPECIFIC_FIELDS_EN = {
    "square": """
        "tl": "Top Left",
        "tr": "Top Right",
        "bl": "Bottom Left",
        "br": "Bottom Right",
        "top_edge": "Top Relationship",
        "bottom_edge": "Bottom Relationship",
        "left_edge": "Left Relationship",
        "right_edge": "Right Relationship",
        "diagonal_insight": "Diagonal Insight"
    """,
    
    "blending": """
        "input_space1": "First Concept",
        "input_space2": "Second Concept",
        "generic_space": "Common Structure",
        "blended_space": "Blended New Meaning",
        "emergent_properties": "Emergent Properties",
        "blend_ratio": "Blend Ratio"
    """,
    
    "sound": """
        "phonetic_analysis": "Phonetic Analysis",
        "sound_meaning": "Sound Meaning",
        "vowel_consonant_ratio": "Vowel/Consonant Ratio",
        "phoneme_emotion_map": "Phoneme-Emotion Mapping",
        "cross_linguistic_sound": "Cross-linguistic Sound Consistency"
    """,
    
    "linguistic": """
        "korean_adaptation": "Korean Adaptation",
        "english_meaning": "English Meaning",
        "cultural_considerations": "Cultural Considerations",
        "avoid_meanings": "Meanings to Avoid",
        "localization_strategy": "Localization Strategy"
    """,
    
    "archetype": """
        "archetype": "Selected Archetype",
        "archetype_traits": "Archetype Traits",
        "shadow_side": "Shadow Side",
        "mythology_reference": "Mythological Reference",
        "customer_journey": "Customer Journey Connection"
    """,
    
    "jobs": """
        "functional_job": "Functional Job",
        "emotional_job": "Emotional Job",
        "social_job": "Social Job",
        "job_statement": "Core Job Statement",
        "outcome_metrics": "Outcome Metrics"
    """,
    
    "scamper": """
        "scamper_technique": "Technique Used",
        "original_concept": "Original Concept",
        "transformation": "Transformation Process",
        "innovation_type": "Innovation Type",
        "disruption_level": "Disruption Level"
    """,
    
    "design": """
        "user_insight": "User Insight",
        "pain_point": "Pain Point Solved",
        "desirability": "Desirability (Human)",
        "feasibility": "Feasibility (Technical)",
        "viability": "Viability (Business)"
    """,
    
    "biomimicry": """
        "natural_inspiration": "Natural Inspiration",
        "biomimetic_principle": "Biomimetic Principle",
        "form_function": "Form and Function",
        "sustainability_aspect": "Sustainability Aspect",
        "adaptation_strategy": "Adaptation Strategy"
    """,
    
    "cognitive": """
        "syllable_count": "Syllable Count",
        "processing_ease": "Processing Ease Score",
        "memory_hooks": "Memory Hooks",
        "cognitive_fluency": "Cognitive Fluency",
        "attention_span_fit": "Attention Span Fit"
    """,
    
    "vonrestorff": """
        "category_norm": "Category Norm",
        "deviation_strategy": "Deviation Strategy",
        "uniqueness_factors": "Uniqueness Factors",
        "attention_triggers": "Attention Triggers",
        "isolation_effect": "Isolation Effect Usage"
    """,
    
    "network": """
        "network_type": "Network Type",
        "viral_coefficient": "Viral Coefficient",
        "sharing_ease": "Sharing Ease",
        "community_aspect": "Community Aspect",
        "network_value": "Network Value"
    """,
    
    "memetics": """
        "meme_structure": "Meme Structure",
        "replication_ease": "Replication Ease",
        "mutation_potential": "Mutation Potential",
        "cultural_fitness": "Cultural Fitness",
        "transmission_channels": "Transmission Channels"
    """,
    
    "color": """
        "color_palette": "Color Palette",
        "emotional_response": "Emotional Response",
        "cultural_associations": "Cultural Associations",
        "industry_alignment": "Industry Alignment",
        "color_accessibility": "Color Accessibility"
    """,
    
    "gestalt": """
        "gestalt_principle": "Principle Used",
        "visual_structure": "Visual Structure",
        "perceptual_grouping": "Perceptual Grouping",
        "figure_ground": "Figure-Ground Relationship",
        "closure_effect": "Closure Effect"
    """
}

# 이론별 특수 필드 정의 (한국어)
THEORY_SPECIFIC_FIELDS_KO = {
    "square": """
        "tl": "왼쪽상단",
        "tr": "오른쪽상단",
        "bl": "왼쪽하단",
        "br": "오른쪽하단",
        "top_edge": "상단 관계",
        "bottom_edge": "하단 관계",
        "left_edge": "왼쪽 관계",
        "right_edge": "오른쪽 관계",
        "diagonal_insight": "대각선 통찰"
    """,
    
    "blending": """
        "input_space1": "첫 번째 개념",
        "input_space2": "두 번째 개념",
        "generic_space": "공통 구조",
        "blended_space": "혼합된 새로운 의미",
        "emergent_properties": "창발적 속성들",
        "blend_ratio": "혼합 비율"
    """,
    
    "sound": """
        "phonetic_analysis": "음성 분석",
        "sound_meaning": "음향이 전달하는 의미",
        "vowel_consonant_ratio": "모음/자음 비율",
        "phoneme_emotion_map": "음소-감정 매핑",
        "cross_linguistic_sound": "언어간 음향 일관성"
    """,
    
    "linguistic": """
        "korean_adaptation": "한국어 적응",
        "english_meaning": "영어 브랜드명",
        "cultural_considerations": "문화적 고려사항",
        "avoid_meanings": "피해야 할 의미들",
        "localization_strategy": "현지화 전략"
    """,
    
    "archetype": """
        "archetype": "선택된 원형",
        "archetype_traits": "원형의 특징들",
        "shadow_side": "그림자 측면",
        "mythology_reference": "신화적 참조",
        "customer_journey": "고객 여정 연결"
    """,
    
    "jobs": """
        "functional_job": "기능적 일",
        "emotional_job": "감정적 일",
        "social_job": "사회적 일",
        "job_statement": "핵심 Job 문장",
        "outcome_metrics": "성과 지표"
    """,
    
    "scamper": """
        "scamper_technique": "사용된 기법",
        "original_concept": "원래 개념",
        "transformation": "변형 과정",
        "innovation_type": "혁신 유형",
        "disruption_level": "파괴적 혁신 수준"
    """,
    
    "design": """
        "user_insight": "사용자 통찰",
        "pain_point": "해결하는 문제점",
        "desirability": "바람직함 (인간)",
        "feasibility": "실현가능성 (기술)",
        "viability": "생존가능성 (비즈니스)"
    """,
    
    "biomimicry": """
        "natural_inspiration": "자연적 영감원",
        "biomimetic_principle": "생체모방 원리",
        "form_function": "형태와 기능",
        "sustainability_aspect": "지속가능성 측면",
        "adaptation_strategy": "적응 전략"
    """,
    
    "cognitive": """
        "syllable_count": "음절 수",
        "processing_ease": "처리 용이성 점수",
        "memory_hooks": "기억 고리",
        "cognitive_fluency": "인지적 유창성",
        "attention_span_fit": "주의력 적합도"
    """,
    
    "vonrestorff": """
        "category_norm": "카테고리 표준",
        "deviation_strategy": "일탈 전략",
        "uniqueness_factors": "독특성 요소들",
        "attention_triggers": "주의 트리거",
        "isolation_effect": "고립 효과 활용"
    """,
    
    "network": """
        "network_type": "네트워크 유형",
        "viral_coefficient": "바이럴 계수",
        "sharing_ease": "공유 용이성",
        "community_aspect": "커뮤니티 측면",
        "network_value": "네트워크 가치"
    """,
    
    "memetics": """
        "meme_structure": "밈 구조",
        "replication_ease": "복제 용이성",
        "mutation_potential": "변이 잠재력",
        "cultural_fitness": "문화적 적합도",
        "transmission_channels": "전달 채널"
    """,
    
    "color": """
        "color_palette": "색상 팔레트",
        "emotional_response": "감정적 반응",
        "cultural_associations": "문화적 연상",
        "industry_alignment": "업종 정렬",
        "color_accessibility": "색상 접근성"
    """,
    
    "gestalt": """
        "gestalt_principle": "활용 원칙",
        "visual_structure": "시각적 구조",
        "perceptual_grouping": "지각적 그룹화",
        "figure_ground": "전경-배경 관계",
        "closure_effect": "폐쇄 효과"
    """
}

def create_theory_prompt(theory: str, language: str) -> str:
    """각 이론별 통일된 프롬프트 생성"""
    theory_names = {
        "en": {
            "square": "Square Theory",
            "blending": "Conceptual Blending Theory",
            "sound": "Sound Symbolism",
            "linguistic": "Linguistic Relativity",
            "archetype": "Jung's Archetype Theory",
            "jobs": "Jobs-to-be-Done Theory",
            "scamper": "SCAMPER Method",
            "design": "IDEO's Design Thinking",
            "biomimicry": "Biomimicry",
            "cognitive": "Cognitive Load Theory",
            "vonrestorff": "Von Restorff Effect",
            "network": "Network Effects",
            "memetics": "Memetics",
            "color": "Color Psychology",
            "gestalt": "Gestalt Theory"
        },
        "ko": {
            "square": "Square Theory",
            "blending": "Conceptual Blending Theory",
            "sound": "Sound Symbolism",
            "linguistic": "Linguistic Relativity",
            "archetype": "Jung의 Archetype Theory",
            "jobs": "Jobs-to-be-Done Theory",
            "scamper": "SCAMPER Method",
            "design": "IDEO의 Design Thinking",
            "biomimicry": "Biomimicry",
            "cognitive": "Cognitive Load Theory",
            "vonrestorff": "Von Restorff Effect",
            "network": "Network Effects",
            "memetics": "Memetics",
            "color": "Color Psychology",
            "gestalt": "Gestalt Theory"
        }
    }
    
    base_prompt = UNIFIED_BASE_PROMPT_EN if language == "en" else UNIFIED_BASE_PROMPT_KO
    theory_specific_fields = THEORY_SPECIFIC_FIELDS_EN if language == "en" else THEORY_SPECIFIC_FIELDS_KO
    
    return base_prompt.format(
        theory_name=theory_names[language][theory],
        theory_description=THEORY_DESCRIPTIONS[language][theory],
        theory_specific_fields=theory_specific_fields[theory]
    )

def generate_by_theory(industry: str, keywords: str, theory: str, language: str, count: int = 3) -> Tuple[str, str, gr.update]:
    """특정 이론으로 브랜드 생성"""
    
    texts = TEXTS[language]
    
    if not industry or not keywords:
        return texts["input_required"], "", gr.update(visible=False)
    
    prompt = create_theory_prompt(theory, language)
    
    if language == "en":
        user_input = f"""Industry: {industry}
Keywords: {keywords}

Generate {count} brands with the above information. 
Each brand should have a unified structure, with theory-specific characteristics in the theory_specific section."""
    else:
        user_input = f"""업종: {industry}
키워드: {keywords}

위 정보로 {count}개의 브랜드를 생성하세요. 
각 브랜드는 통일된 구조를 가지되, theory_specific 섹션에는 {theory} 이론의 특성을 반영하세요.
중요: linguistic > global_adaptability 필드에 반드시 영어 브랜드명을 포함하세요."""
    
    try:
        # 프로그레스바 표시
        theory_names = {
            "square": "Square Theory",
            "blending": "Conceptual Blending",
            "sound": "Sound Symbolism",
            "linguistic": "Linguistic Relativity",
            "archetype": "Archetype Theory",
            "jobs": "Jobs-to-be-Done",
            "scamper": "SCAMPER Method",
            "design": "Design Thinking",
            "biomimicry": "Biomimicry",
            "cognitive": "Cognitive Load Theory",
            "vonrestorff": "Von Restorff Effect",
            "network": "Network Effects",
            "memetics": "Memetics",
            "color": "Color Psychology",
            "gestalt": "Gestalt Principles"
        }
        
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": prompt},
                {"role": "user", "content": user_input}
            ],
            temperature=0.8,
            max_tokens=2000,
            response_format={"type": "json_object"}
        )
        
        content = response.choices[0].message.content
        data = json.loads(content)
        
        # 응답 정규화
        if "brands" in data:
            results = data["brands"]
        else:
            results = [data]
            
        if not isinstance(results, list):
            results = [results]
        
        # 마크다운 생성
        markdown = generate_unified_markdown(theory, results, industry, keywords, language)
        
        # HTML 시각화 생성
        html = generate_unified_visualization(theory, results, language)
        
        return markdown, html, gr.update(visible=False)
        
    except Exception as e:
        error_msg = texts["error_message"].format(theory=theory_names[theory], error=str(e))
        print(error_msg)
        return error_msg, "", gr.update(visible=False)

def generate_unified_markdown(theory: str, results: List[Dict], industry: str, keywords: str, language: str) -> str:
    """통일된 마크다운 생성"""
    
    theory_names = {
        "square": "Square Theory",
        "blending": "Conceptual Blending",
        "sound": "Sound Symbolism",
        "linguistic": "Linguistic Relativity",
        "archetype": "Archetype Theory",
        "jobs": "Jobs-to-be-Done",
        "scamper": "SCAMPER Method",
        "design": "Design Thinking",
        "biomimicry": "Biomimicry",
        "cognitive": "Cognitive Load Theory",
        "vonrestorff": "Von Restorff Effect",
        "network": "Network Effects",
        "memetics": "Memetics",
        "color": "Color Psychology",
        "gestalt": "Gestalt Principles"
    }
    
    theory_icons = {
        "square": "🟦", "blending": "🔀", "sound": "🔊", "linguistic": "🌐",
        "archetype": "🎭", "jobs": "✅", "scamper": "🔧", "design": "💭",
        "biomimicry": "🌿", "cognitive": "🧠", "vonrestorff": "⚡", "network": "🌍",
        "memetics": "🧬", "color": "🎨", "gestalt": "👁️"
    }
    
    texts = TEXTS[language]
    
    if language == "en":
        markdown = f"""# {theory_icons[theory]} {theory_names[theory]}

<div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
    <h3 style="margin: 0 0 10px 0;">Theory Overview</h3>
    <p style="margin: 0; line-height: 1.6;">{THEORY_DESCRIPTIONS[language][theory]}</p>
</div>

**Industry**: {industry} | **Keywords**: {keywords}  
*Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*

---
"""
    else:
        markdown = f"""# {theory_icons[theory]} {theory_names[theory]}

<div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
    <h3 style="margin: 0 0 10px 0;">이론 개요</h3>
    <p style="margin: 0; line-height: 1.6;">{THEORY_DESCRIPTIONS[language][theory]}</p>
</div>

**업종**: {industry} | **키워드**: {keywords}  
*생성 시각: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*

---
"""
    
    for idx, result in enumerate(results, 1):
        core = result.get('core', {})
        visual = result.get('visual', {})
        linguistic = result.get('linguistic', {})
        strategic = result.get('strategic', {})
        theory_specific = result.get('theory_specific', {})
        evaluation = result.get('evaluation', {})
        
        brand_name = core.get('brand_name', 'N/A')
        slogan = core.get('slogan', 'N/A')
        
        # 한글일 경우 영어 표현 추가
        if language == "ko":
            # 우선순위에 따라 영어명 찾기
            english_name = None
            
            # 1. linguistic theory의 경우 theory_specific에서 찾기
            if theory == "linguistic" and 'english_meaning' in theory_specific:
                english_name = theory_specific.get('english_meaning', '')
            
            # 2. global_adaptability에서 찾기
            if not english_name or english_name == 'N/A':
                english_name = linguistic.get('global_adaptability', '')
            
            # 3. etymology에서 영어 추출
            if not english_name or english_name == 'N/A':
                etymology = linguistic.get('etymology', '')
                if etymology and '영어' in etymology and ':' in etymology:
                    # "영어: Brand Name" 형식에서 추출
                    parts = etymology.split(':')
                    for i, part in enumerate(parts):
                        if '영어' in part and i + 1 < len(parts):
                            english_name = parts[i + 1].strip().split(',')[0].strip()
                            break
            
            # 영어명이 유효한 경우에만 추가
            if english_name and english_name != 'N/A' and english_name != brand_name:
                # 길이가 너무 길거나 설명이 포함된 경우 정리
                if len(english_name) > 50 or '(' in english_name or ',' in english_name:
                    english_name = english_name.split('(')[0].split(',')[0].strip()
                
                # 영어명이 실제로 영어인지 간단히 확인 (한글이 포함되지 않았는지)
                if not any(ord(char) >= 0xAC00 and ord(char) <= 0xD7A3 for char in english_name):
                    brand_display = f"{brand_name} / {english_name}"
                else:
                    brand_display = brand_name
            else:
                brand_display = brand_name
        else:
            brand_display = brand_name
        
        markdown += f"\n## {idx}. {brand_display}\n"
        
        if language == "en":
            markdown += f"""**Slogan**: *"{slogan}"*

### 📍 Core Information
- **Core Value**: {core.get('core_value', 'N/A')}
- **Target Emotion**: {core.get('target_emotion', 'N/A')}
- **Brand Personality**: {core.get('brand_personality', 'N/A')}

### 🎨 Visual Concept
- **Primary Color**: {visual.get('primary_color', '#000000')} - {visual.get('color_meaning', 'N/A')}
- **Visual Concept**: {visual.get('visual_concept', 'N/A')}
- **Typography**: {visual.get('typography_style', 'N/A')}

### 🗣️ Linguistic Features
- **Pronunciation**: {linguistic.get('pronunciation', 'N/A')}
- **Etymology**: {linguistic.get('etymology', 'N/A')}
- **Global Adaptability**: {linguistic.get('global_adaptability', 'N/A')}

### 🎯 Strategic Value
- **Differentiation**: {strategic.get('differentiation', 'N/A')}
- **Market Positioning**: {strategic.get('market_positioning', 'N/A')}
- **Growth Potential**: {strategic.get('growth_potential', 'N/A')}
"""
        else:
            markdown += f"""**슬로건**: *"{slogan}"*

### 📍 핵심 정보
- **핵심 가치**: {core.get('core_value', 'N/A')}
- **목표 감정**: {core.get('target_emotion', 'N/A')}
- **브랜드 성격**: {core.get('brand_personality', 'N/A')}

### 🎨 시각적 컨셉
- **주요 색상**: {visual.get('primary_color', '#000000')} - {visual.get('color_meaning', 'N/A')}
- **비주얼 컨셉**: {visual.get('visual_concept', 'N/A')}
- **타이포그래피**: {visual.get('typography_style', 'N/A')}

### 🗣️ 언어적 특성
- **발음**: {linguistic.get('pronunciation', 'N/A')}
- **어원/구성**: {linguistic.get('etymology', 'N/A')}
- **글로벌 적응성**: {linguistic.get('global_adaptability', 'N/A')}

### 🎯 전략적 가치
- **차별화 포인트**: {strategic.get('differentiation', 'N/A')}
- **시장 포지셔닝**: {strategic.get('market_positioning', 'N/A')}
- **성장 잠재력**: {strategic.get('growth_potential', 'N/A')}
"""
        
        # 이론별 특수 정보
        if theory_specific:
            theory_header = f"### 💡 {theory_names[theory]} " + ("Features" if language == "en" else "특성") + "\n"
            markdown += theory_header
            for key, value in theory_specific.items():
                display_key = key.replace('_', ' ').title()
                markdown += f"- **{display_key}**: {value}\n"
        
        # 평가 점수
        eval_labels = texts["evaluation_labels"]
        
        if language == "en":
            markdown += f"""
### 📊 Evaluation
- **{eval_labels['creativity']}**: {'⭐' * int(evaluation.get('creativity_score', 0))} ({evaluation.get('creativity_score', 0)}/10)
- **{eval_labels['memorability']}**: {'⭐' * int(evaluation.get('memorability_score', 0))} ({evaluation.get('memorability_score', 0)}/10)
- **{eval_labels['relevance']}**: {'⭐' * int(evaluation.get('relevance_score', 0))} ({evaluation.get('relevance_score', 0)}/10)

💬 **Overall Assessment**: {evaluation.get('overall_effectiveness', 'N/A')}
"""
        else:
            markdown += f"""
### 📊 평가
- **{eval_labels['creativity']}**: {'⭐' * int(evaluation.get('creativity_score', 0))} ({evaluation.get('creativity_score', 0)}/10)
- **{eval_labels['memorability']}**: {'⭐' * int(evaluation.get('memorability_score', 0))} ({evaluation.get('memorability_score', 0)}/10)
- **{eval_labels['relevance']}**: {'⭐' * int(evaluation.get('relevance_score', 0))} ({evaluation.get('relevance_score', 0)}/10)

💬 **전체 평가**: {evaluation.get('overall_effectiveness', 'N/A')}
"""
        
        markdown += "\n---\n"
    
    return markdown

def generate_unified_visualization(theory: str, results: List[Dict], language: str) -> str:
    """통일된 시각화 생성"""
    
    texts = TEXTS[language]
    eval_labels = texts["evaluation_labels"]
    
    html_parts = []
    
    for idx, result in enumerate(results, 1):
        core = result.get('core', {})
        visual = result.get('visual', {})
        linguistic = result.get('linguistic', {})
        strategic = result.get('strategic', {})
        theory_specific = result.get('theory_specific', {})
        evaluation = result.get('evaluation', {})
        
        brand_name = core.get('brand_name', 'Brand')
        slogan = core.get('slogan', '')
        primary_color = visual.get('primary_color', '#667eea')
        
        # 한글일 경우 영어 표현 추가
        if language == "ko":
            # 우선순위에 따라 영어명 찾기
            english_name = None
            
            # 1. linguistic theory의 경우 theory_specific에서 찾기
            if theory == "linguistic" and 'english_meaning' in theory_specific:
                english_name = theory_specific.get('english_meaning', '')
            
            # 2. global_adaptability에서 찾기
            if not english_name or english_name == 'N/A':
                english_name = linguistic.get('global_adaptability', '')
            
            # 3. etymology에서 영어 추출
            if not english_name or english_name == 'N/A':
                etymology = linguistic.get('etymology', '')
                if etymology and '영어' in etymology and ':' in etymology:
                    # "영어: Brand Name" 형식에서 추출
                    parts = etymology.split(':')
                    for i, part in enumerate(parts):
                        if '영어' in part and i + 1 < len(parts):
                            english_name = parts[i + 1].strip().split(',')[0].strip()
                            break
            
            # 영어명이 유효한 경우에만 추가
            if english_name and english_name != 'N/A' and english_name != brand_name:
                # 길이가 너무 길거나 설명이 포함된 경우 정리
                if len(english_name) > 50 or '(' in english_name or ',' in english_name:
                    english_name = english_name.split('(')[0].split(',')[0].strip()
                
                # 영어명이 실제로 영어인지 간단히 확인 (한글이 포함되지 않았는지)
                if not any(ord(char) >= 0xAC00 and ord(char) <= 0xD7A3 for char in english_name):
                    brand_display = f"{brand_name} / {english_name}"
                else:
                    brand_display = brand_name
            else:
                brand_display = brand_name
        else:
            brand_display = brand_name
        
        # 언어별 라벨
        if language == "en":
            labels = {
                "core_value": "Core Value",
                "target_emotion": "Target Emotion",
                "differentiation": "Differentiation",
                "pronunciation": "Pronunciation"
            }
        else:
            labels = {
                "core_value": "핵심 가치",
                "target_emotion": "목표 감정",
                "differentiation": "차별화 포인트",
                "pronunciation": "발음 가이드"
            }
        
        # 통일된 카드 레이아웃
        html = f"""
<div style="max-width: 800px; margin: 30px auto; font-family: -apple-system, sans-serif;">
    <div style="background: white; border-radius: 20px; box-shadow: 0 10px 40px rgba(0,0,0,0.1); overflow: hidden;">
        <!-- 헤더 -->
        <div style="background: linear-gradient(135deg, {primary_color} 0%, #2c3e50 100%); padding: 40px; color: white;">
            <h2 style="margin: 0 0 10px 0; font-size: 2.5em;">{brand_display}</h2>
            <p style="margin: 0; font-style: italic; font-size: 1.2em; opacity: 0.9;">"{slogan}"</p>
        </div>
        
        <!-- 본문 -->
        <div style="padding: 40px;">
            <!-- 평가 점수 -->
            <div style="display: flex; justify-content: space-around; margin-bottom: 30px;">
                <div style="text-align: center;">
                    <div style="font-size: 2em; color: {primary_color}; font-weight: bold;">
                        {evaluation.get('creativity_score', 0)}/10
                    </div>
                    <div style="color: #7f8c8d; margin-top: 5px;">{eval_labels['creativity']}</div>
                </div>
                <div style="text-align: center;">
                    <div style="font-size: 2em; color: {primary_color}; font-weight: bold;">
                        {evaluation.get('memorability_score', 0)}/10
                    </div>
                    <div style="color: #7f8c8d; margin-top: 5px;">{eval_labels['memorability']}</div>
                </div>
                <div style="text-align: center;">
                    <div style="font-size: 2em; color: {primary_color}; font-weight: bold;">
                        {evaluation.get('relevance_score', 0)}/10
                    </div>
                    <div style="color: #7f8c8d; margin-top: 5px;">{eval_labels['relevance']}</div>
                </div>
            </div>
            
            <!-- 핵심 정보 그리드 -->
            <div style="display: grid; grid-template-columns: repeat(2, 1fr); gap: 20px; margin-bottom: 30px;">
                <div style="background: #f8f9fa; padding: 20px; border-radius: 10px;">
                    <h4 style="margin: 0 0 10px 0; color: {primary_color};">{labels['core_value']}</h4>
                    <p style="margin: 0; color: #555;">{core.get('core_value', 'N/A')}</p>
                </div>
                <div style="background: #f8f9fa; padding: 20px; border-radius: 10px;">
                    <h4 style="margin: 0 0 10px 0; color: {primary_color};">{labels['target_emotion']}</h4>
                    <p style="margin: 0; color: #555;">{core.get('target_emotion', 'N/A')}</p>
                </div>
                <div style="background: #f8f9fa; padding: 20px; border-radius: 10px;">
                    <h4 style="margin: 0 0 10px 0; color: {primary_color};">{labels['differentiation']}</h4>
                    <p style="margin: 0; color: #555;">{strategic.get('differentiation', 'N/A')}</p>
                </div>
                <div style="background: #f8f9fa; padding: 20px; border-radius: 10px;">
                    <h4 style="margin: 0 0 10px 0; color: {primary_color};">{labels['pronunciation']}</h4>
                    <p style="margin: 0; color: #555;">{linguistic.get('pronunciation', 'N/A')}</p>
                </div>
            </div>
"""
        
        # 이론별 특수 시각화 추가
        if theory == "square" and all(k in theory_specific for k in ['tl', 'tr', 'bl', 'br']):
            html += visualize_square_specific(theory_specific, primary_color)
        elif theory == "blending" and 'input_space1' in theory_specific:
            html += visualize_blending_specific(theory_specific, primary_color)
        elif theory == "color" and 'color_palette' in theory_specific:
            html += visualize_color_specific(theory_specific, primary_color)
        else:
            # 기본 이론 특성 표시
            theory_header = "Theory Features" if language == "en" else "이론 특성"
            html += f"""
            <div style="background: linear-gradient(135deg, {primary_color}15 0%, {primary_color}05 100%); padding: 25px; border-radius: 15px; margin-top: 20px;">
                <h4 style="margin: 0 0 15px 0; color: {primary_color};">{theory_header}</h4>
                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px;">
"""
            for key, value in theory_specific.items():
                display_key = key.replace('_', ' ').title()
                html += f"""
                    <div>
                        <strong style="color: #555;">{display_key}:</strong><br>
                        <span style="color: #777;">{value}</span>
                    </div>
"""
            html += """
                </div>
            </div>
"""
        
        # 전체 평가
        overall_header = "Overall Assessment" if language == "en" else "전체 평가"
        html += f"""
            <div style="background: #f8f9fa; padding: 20px; border-radius: 10px; margin-top: 20px;">
                <h4 style="margin: 0 0 10px 0; color: {primary_color};">{overall_header}</h4>
                <p style="margin: 0; color: #555; line-height: 1.6;">{evaluation.get('overall_effectiveness', 'N/A')}</p>
            </div>
        </div>
    </div>
</div>
"""
        
        html_parts.append(html)
    
    return "\n".join(html_parts)

def visualize_square_specific(theory_specific: Dict, primary_color: str) -> str:
    """Square Theory 특수 시각화"""
    return f"""
    <div style="background: #f8f9fa; padding: 30px; border-radius: 15px; margin-top: 20px;">
        <h4 style="margin: 0 0 20px 0; color: {primary_color}; text-align: center;">Square Structure</h4>
        <div style="position: relative; width: 100%; max-width: 400px; height: 300px; margin: 0 auto;">
            <div style="position: absolute; top: 0; left: 0; background: white; color: {primary_color}; padding: 15px 20px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); font-weight: bold;">
                {theory_specific.get('tl', '?')}
            </div>
            <div style="position: absolute; top: 0; right: 0; background: white; color: {primary_color}; padding: 15px 20px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); font-weight: bold;">
                {theory_specific.get('tr', '?')}
            </div>
            <div style="position: absolute; bottom: 0; left: 0; background: white; color: {primary_color}; padding: 15px 20px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); font-weight: bold;">
                {theory_specific.get('bl', '?')}
            </div>
            <div style="position: absolute; bottom: 0; right: 0; background: white; color: {primary_color}; padding: 15px 20px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); font-weight: bold;">
                {theory_specific.get('br', '?')}
            </div>
            
            <!-- 연결선과 관계 표시 -->
            <div style="position: absolute; top: 25px; left: 50%; transform: translateX(-50%); color: #7f8c8d; font-size: 0.9em;">
                {theory_specific.get('top_edge', '')}
            </div>
            <div style="position: absolute; bottom: 25px; left: 50%; transform: translateX(-50%); color: #7f8c8d; font-size: 0.9em;">
                {theory_specific.get('bottom_edge', '')}
            </div>
            <div style="position: absolute; top: 50%; left: 25px; transform: translateY(-50%) rotate(-90deg); color: #7f8c8d; font-size: 0.9em;">
                {theory_specific.get('left_edge', '')}
            </div>
            <div style="position: absolute; top: 50%; right: 25px; transform: translateY(-50%) rotate(90deg); color: #7f8c8d; font-size: 0.9em;">
                {theory_specific.get('right_edge', '')}
            </div>
        </div>
    </div>
"""

def visualize_blending_specific(theory_specific: Dict, primary_color: str) -> str:
    """Conceptual Blending 특수 시각화"""
    return f"""
    <div style="background: #f8f9fa; padding: 30px; border-radius: 15px; margin-top: 20px;">
        <h4 style="margin: 0 0 20px 0; color: {primary_color}; text-align: center;">Concept Blending</h4>
        <div style="display: flex; justify-content: center; align-items: center; gap: 20px; flex-wrap: wrap;">
            <div style="text-align: center; padding: 20px; background: white; color: {primary_color}; border-radius: 50%; width: 120px; height: 120px; display: flex; align-items: center; justify-content: center; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
                <div>
                    <strong>Input 1</strong><br>
                    <span style="font-size: 0.9em;">{theory_specific.get('input_space1', '')}</span>
                </div>
            </div>
            
            <div style="font-size: 2em; color: {primary_color};">+</div>
            
            <div style="text-align: center; padding: 20px; background: white; color: {primary_color}; border-radius: 50%; width: 120px; height: 120px; display: flex; align-items: center; justify-content: center; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
                <div>
                    <strong>Input 2</strong><br>
                    <span style="font-size: 0.9em;">{theory_specific.get('input_space2', '')}</span>
                </div>
            </div>
            
            <div style="font-size: 2em; color: {primary_color};">=</div>
            
            <div style="text-align: center; padding: 20px; background: {primary_color}; color: white; border-radius: 20px; min-width: 150px; box-shadow: 0 2px 10px rgba(0,0,0,0.1);">
                <strong>Blend</strong><br>
                <span style="font-size: 0.95em;">{theory_specific.get('blended_space', '')}</span>
            </div>
        </div>
    </div>
"""

def visualize_color_specific(theory_specific: Dict, primary_color: str) -> str:
    """Color Psychology 특수 시각화"""
    palette = theory_specific.get('color_palette', primary_color)
    colors = palette.split(',') if ',' in palette else [primary_color]
    
    html = f"""
    <div style="background: #f8f9fa; padding: 30px; border-radius: 15px; margin-top: 20px;">
        <h4 style="margin: 0 0 20px 0; color: {primary_color}; text-align: center;">Color Palette</h4>
        <div style="display: flex; justify-content: center; gap: 10px; flex-wrap: wrap;">
"""
    
    for color in colors[:5]:  # 최대 5개 색상만 표시
        color = color.strip()
        html += f"""
            <div style="width: 80px; height: 80px; background: {color}; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1);"></div>
"""
    
    html += """
        </div>
    </div>
"""
    return html

# Gradio UI
with gr.Blocks(
    title="THEORIA™ - Theory-driven Naming AI",
    theme=gr.themes.Soft(),
    css="""
    .gradio-container {
        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
        max-width: 1400px !important;
    }
    /* 탭 네비게이션 스타일 개선 */
    .tab-nav {
        display: grid !important;
        grid-template-columns: repeat(5, 1fr) !important;
        gap: 8px !important;
        padding: 15px !important;
        background: #f8f9fa !important;
        border-radius: 10px !important;
        margin-bottom: 20px !important;
    }
    .tab-nav button {
        font-size: 0.8em !important;
        padding: 10px 8px !important;
        white-space: normal !important;
        line-height: 1.3 !important;
        height: auto !important;
        min-height: 50px !important;
        display: flex !important;
        align-items: center !important;
        justify-content: center !important;
        text-align: center !important;
        border-radius: 8px !important;
        transition: all 0.3s ease !important;
    }
    .tab-nav button:hover {
        transform: translateY(-2px) !important;
        box-shadow: 0 4px 12px rgba(0,0,0,0.15) !important;
    }
    .tab-nav button.selected {
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
        color: white !important;
        font-weight: 600 !important;
    }
    /* 모바일 반응형 */
    @media (max-width: 768px) {
        .tab-nav {
            grid-template-columns: repeat(3, 1fr) !important;
        }
    }
    @media (max-width: 480px) {
        .tab-nav {
            grid-template-columns: repeat(2, 1fr) !important;
        }
    }
    @keyframes pulse {
        0% { opacity: 0.6; }
        50% { opacity: 1; }
        100% { opacity: 0.6; }
    }
    .progress-bar {
        animation: pulse 1.5s ease-in-out infinite;
    }
    """
) as demo:
    # 언어 상태 관리
    current_language = gr.State(value="en")
    
    def update_ui_language(language):
        """UI 언어 업데이트"""
        texts = TEXTS[language]
        
        return (
            language,  # current_language state update
            # Title section update
            gr.update(value=f"""
    <div style="text-align: center; padding: 30px 0;">
        <h1 style="font-size: 3em; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin-bottom: 10px;">
            {texts['title']}
        </h1>
        <p style="font-size: 1.4em; color: #7f8c8d; font-weight: 500;">{texts['subtitle']}</p>
        <p style="font-size: 1.1em; color: #95a5a6; margin-top: 10px;">{texts['description']}</p>
    </div>
    """),
            gr.update(label=texts['industry_label'], placeholder=texts['industry_placeholder']),
            gr.update(label=texts['keywords_label'], placeholder=texts['keywords_placeholder'], info=texts['keywords_info']),
        )
    
    # 헤더
    title_section = gr.Markdown("""
    <div style="text-align: center; padding: 30px 0;">
        <h1 style="font-size: 3em; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin-bottom: 10px;">
            THEORIA™
        </h1>
        <p style="font-size: 1.4em; color: #7f8c8d; font-weight: 500;">Theory-driven Naming AI with 15 Specialized Theories</p>
        <p style="font-size: 1.1em; color: #95a5a6; margin-top: 10px;">Generate innovative brand names using 15 cognitive and creative theories</p>
    </div>
    """)
    
    with gr.Row():
        with gr.Column(scale=1, min_width=250):
            gr.Markdown("""
            <div style="background: #f8f9fa; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
                <h3 style="margin-top: 0; color: #2c3e50;">📝 Brand Information</h3>
            </div>
            """)
            
            # 언어 선택
            language_selector = gr.Radio(
                choices=[("English", "en"), ("한국어", "ko")],
                value="en",
                label="🌐 Language",
                info="Select output language"
            )
            
            industry_input = gr.Textbox(
                label="🏭 Industry",
                placeholder="e.g., cafe, fitness, education, beauty...",
                value="카페/커피숍"
            )
            
            keywords_input = gr.Textbox(
                label="🔑 Keywords",
                placeholder="premium, comfortable, urban, eco-friendly...",
                info="Core values or characteristics the brand should embody",
                lines=2
            )
            
            # 언어 변경 이벤트
            language_selector.change(
                update_ui_language,
                inputs=[language_selector],
                outputs=[current_language, title_section, industry_input, keywords_input]
            )
            
            gr.Markdown("""
            <div style="background: #e3f2fd; padding: 15px; border-radius: 8px; margin-top: 20px;">
                <h4 style="margin-top: 0; color: #1976d2;">🎯 15 Theories</h4>
                <p style="margin: 10px 0; font-size: 0.9em;">Each theory offers unique approach:</p>
                <ul style="margin: 5px 0; padding-left: 20px; font-size: 0.8em; line-height: 1.4;">
                    <li><strong>Cognitive</strong>: Square, Sound, Cognitive, Gestalt</li>
                    <li><strong>Creative</strong>: Blending, SCAMPER, Biomimicry</li>
                    <li><strong>Strategic</strong>: Jobs-to-be-Done, Design</li>
                    <li><strong>Cultural</strong>: Archetype, Linguistic, Memetics</li>
                    <li><strong>Distinctive</strong>: Von Restorff, Color, Network</li>
                </ul>
            </div>
            
            <div style="background: #fff3cd; padding: 15px; border-radius: 8px; margin-top: 15px;">
                <h4 style="margin-top: 0; color: #856404;">💡 Tips</h4>
                <ul style="margin: 5px 0; padding-left: 20px; font-size: 0.8em; line-height: 1.4;">
                    <li>Try multiple theories</li>
                    <li>Compare results</li>
                    <li>Combine insights</li>
                </ul>
            </div>
            """)
        
        with gr.Column(scale=4):
            # 15개 탭을 3개 행으로 구성
            gr.Markdown("""
            <div style="background: #f8f9fa; padding: 15px; border-radius: 10px; margin-bottom: 20px;">
                <h3 style="margin: 0; color: #2c3e50; text-align: center;">Select a Theory to Generate Names</h3>
            </div>
            """)
            
            # 15개 탭 생성
            with gr.Tabs(elem_classes="tab-nav"):
                theories = [
                    ("🟦 Square Theory", "square"),
                    ("🔀 Conceptual Blending", "blending"),
                    ("🔊 Sound Symbolism", "sound"),
                    ("🌐 Linguistic Relativity", "linguistic"),
                    ("🎭 Archetype Theory", "archetype"),
                    ("✅ Jobs-to-be-Done", "jobs"),
                    ("🔧 SCAMPER Method", "scamper"),
                    ("💭 Design Thinking", "design"),
                    ("🌿 Biomimicry", "biomimicry"),
                    ("🧠 Cognitive Load", "cognitive"),
                    ("⚡ Von Restorff Effect", "vonrestorff"),
                    ("🌍 Network Effects", "network"),
                    ("🧬 Memetics", "memetics"),
                    ("🎨 Color Psychology", "color"),
                    ("👁️ Gestalt Principles", "gestalt")
                ]
                
                for tab_name, theory_key in theories:
                    with gr.Tab(tab_name):
                        with gr.Column():
                            # 프로그레스 메시지
                            progress_msg = gr.Markdown(
                                visible=False
                            )
                            
                            with gr.Row():
                                btn = gr.Button(
                                    f"Generate with {tab_name}", 
                                    variant="primary", 
                                    size="lg",
                                    elem_id=f"btn_{theory_key}"
                                )
                            
                            output = gr.Markdown()
                            visual = gr.HTML()
                            
                            def show_progress(industry, keywords, theory, language, tab_name):
                                """프로그레스바 표시"""
                                if not industry or not keywords:
                                    return "", "", gr.update(visible=False)
                                
                                texts = TEXTS[language]
                                progress_text = texts["progress_message"].format(theory=tab_name)
                                
                                progress_html = f"""
                                <div style="text-align: center; padding: 20px; background: #f0f8ff; border-radius: 10px; margin: 10px 0;">
                                    <div class="progress-bar" style="font-size: 1.2em; color: #1976d2;">
                                        {progress_text}
                                    </div>
                                    <div style="margin-top: 10px;">
                                        <div style="width: 100%; background: #e0e0e0; border-radius: 5px; overflow: hidden;">
                                            <div style="width: 100%; height: 4px; background: linear-gradient(90deg, #1976d2 0%, #42a5f5 50%, #1976d2 100%); animation: slide 1.5s linear infinite;"></div>
                                        </div>
                                    </div>
                                </div>
                                <style>
                                @keyframes slide {{
                                    0% {{ transform: translateX(-100%); }}
                                    100% {{ transform: translateX(100%); }}
                                }}
                                </style>
                                """
                                return "", "", gr.update(visible=True, value=progress_html)
                            
                            def generate_and_hide_progress(industry, keywords, theory, language):
                                """생성 후 프로그레스바 숨김"""
                                result_md, result_html, _ = generate_by_theory(industry, keywords, theory, language)
                                return result_md, result_html, gr.update(visible=False)
                            
                            # 프로그레스바 표시
                            btn.click(
                                lambda i, k, l, t=theory_key, n=tab_name: show_progress(i, k, t, l, n),
                                inputs=[industry_input, keywords_input, current_language],
                                outputs=[output, visual, progress_msg]
                            ).then(
                                # 실제 생성 작업
                                lambda i, k, l, t=theory_key: generate_and_hide_progress(i, k, t, l),
                                inputs=[industry_input, keywords_input, current_language],
                                outputs=[output, visual, progress_msg]
                            )
    
    gr.Markdown("""
    <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 40px; border-radius: 15px; margin-top: 40px;">
        <h3 style="margin-top: 0; text-align: center;">🏆 Why THEORIA™?</h3>
        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 25px; margin-top: 25px;">
            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px;">
                <h4 style="margin: 0 0 10px 0;">🧪 Scientific Foundation</h4>
                <p style="margin: 0; font-size: 0.95em;">Based on proven cognitive and creative theories from psychology, linguistics, and design</p>
            </div>
            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px;">
                <h4 style="margin: 0 0 10px 0;">🎯 Multi-dimensional Approach</h4>
                <p style="margin: 0; font-size: 0.95em;">15 different perspectives ensure you find the perfect name for your brand</p>
            </div>
            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px;">
                <h4 style="margin: 0 0 10px 0;">📊 Unified Evaluation</h4>
                <p style="margin: 0; font-size: 0.95em;">Consistent scoring system allows easy comparison across all theories</p>
            </div>
            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px;">
                <h4 style="margin: 0 0 10px 0;">🌍 Global Ready</h4>
                <p style="margin: 0; font-size: 0.95em;">Multilingual support and cultural considerations built into every theory</p>
            </div>
        </div>
        
        <div style="text-align: center; margin-top: 30px; padding-top: 20px; border-top: 1px solid rgba(255,255,255,0.2);">
            <p style="margin: 0; font-size: 0.9em; opacity: 0.8;">
                THEORIA™ - Where Science Meets Creativity in Brand Naming
            </p>
        </div>
    </div>
    """)

if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False
    )