app.py

import gradio as gr
import pandas as pd
import numpy as np
from datetime import datetime
import plotly.graph_objects as go
import re
from urllib.parse import urlparse
import requests
import json
import os

class StartupValuationCalculator:
    def __init__(self):
        # 업종별 벤치마크 멀티플 (EV/ARR)
        self.industry_multiples = {
            "SaaS - B2B": {"low": 3, "mid": 6, "high": 10},
            "SaaS - B2C": {"low": 2, "mid": 4, "high": 7},
            "마켓플레이스": {"low": 2, "mid": 5, "high": 8},
            "이커머스": {"low": 1, "mid": 2.5, "high": 4},
            "핀테크": {"low": 3, "mid": 5, "high": 8},
            "헬스케어": {"low": 4, "mid": 7, "high": 12},
            "AI/딥테크": {"low": 5, "mid": 8, "high": 15},
            "기타": {"low": 2, "mid": 4, "high": 6}
        }
        
        # 성장률 조정 계수
        self.growth_adjustments = {
            "0-20%": 0.7,
            "20-50%": 0.9,
            "50-100%": 1.1,
            "100-200%": 1.3,
            "200%+": 1.5
        }
        
        # 버크스 방법 카테고리별 최대값 ($500K each)
        self.berkus_max_values = {
            "sound_idea": 500000,
            "prototype": 500000,
            "quality_team": 500000,
            "strategic_relationships": 500000,
            "product_rollout": 500000
        }
        
        # 스코어카드 가중치
        self.scorecard_weights = {
            "team": 0.30,
            "market_size": 0.25,
            "product": 0.15,
            "competition": 0.10,
            "marketing": 0.10,
            "need_for_funding": 0.05,
            "other": 0.05
        }
        
        # 언어별 텍스트
        self.translations = {
            "ko": {
                "title": "🦄 스타트업 가치평가 자동화 시스템 v3.0",
                "subtitle": "버크스 방법과 스코어카드 방법을 포함한 종합 평가",
                "valuation_result": "가치평가 결과",
                "company_value": "기업가치",
                "arr": "연간 반복 매출",
                "multiple": "적용 멀티플",
                "unit_economics": "단위경제",
                "berkus_score": "버크스 평가",
                "scorecard_score": "스코어카드 평가",
                "financial_health": "재무 건전성",
                "insights": "평가 인사이트"
            },
            "en": {
                "title": "🦄 Startup Valuation System v3.0",
                "subtitle": "Comprehensive valuation with Berkus and Scorecard methods",
                "valuation_result": "Valuation Result",
                "company_value": "Company Value",
                "arr": "Annual Recurring Revenue",
                "multiple": "Applied Multiple",
                "unit_economics": "Unit Economics",
                "berkus_score": "Berkus Score",
                "scorecard_score": "Scorecard Score",
                "financial_health": "Financial Health",
                "insights": "Valuation Insights"
            }
        }
    
    def call_llm_api(self, prompt, api_key):
        """LLM API를 호출하여 고급 분석 수행"""
        if not api_key:
            return None
            
        url = "https://api.fireworks.ai/inference/v1/chat/completions"
        
        payload = {
            "model": "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507",
            "max_tokens": 4096,
            "top_p": 1,
            "top_k": 40,
            "presence_penalty": 0,
            "frequency_penalty": 0,
            "temperature": 0.6,
            "messages": [
                {
                    "role": "system",
                    "content": "You are an expert startup valuation analyst and strategic advisor with deep knowledge of venture capital, financial analysis, and business strategy."
                },
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        }
        
        headers = {
            "Accept": "application/json",
            "Content-Type": "application/json",
            "Authorization": f"Bearer {api_key}"
        }
        
        try:
            response = requests.post(url, headers=headers, data=json.dumps(payload))
            if response.status_code == 200:
                return response.json()['choices'][0]['message']['content']
            else:
                return None
        except:
            return None
    
    def generate_strategic_report(self, data, results, language, api_key):
        """LLM을 사용하여 전략적 보고서 생성"""
        
        if language == "ko":
            prompt = f"""
다음 스타트업의 가치평가 결과를 분석하고 전략적 조언을 포함한 상세 보고서를 작성해주세요:

회사 정보:
- 회사명: {data['company_name']}
- 설립년도: {data['founded_year']}
- 산업: {data['industry']}
- 사업 단계: {data['stage']}

평가 결과:
- 최종 기업가치: ${results['final_valuation']/1000000:.2f}M
- 버크스 평가: ${results['berkus_valuation']/1000000:.2f}M
- ARR: ${results['arr']/1000000:.2f}M
- 성장률: {data['growth_rate']}%
- LTV/CAC: {results['ltv_cac_ratio']:.1f}
- 런웨이: {results['runway']:.1f}개월
- 스코어카드 점수들: {results['scorecard_adjustments']}

다음을 포함하여 작성해주세요:
1. 가치평가 결과의 타당성 분석
2. 동종업계 대비 포지셔닝
3. 주요 강점과 개선 필요 영역
4. 향후 6-12개월 전략적 우선순위
5. 자금조달 전략 및 적정 조달 규모
6. 주요 리스크와 완화 방안
7. 핵심 KPI와 마일스톤 제안
"""
        else:
            prompt = f"""
Please analyze the following startup valuation results and provide a comprehensive strategic report:

Company Information:
- Company Name: {data['company_name']}
- Founded: {data['founded_year']}
- Industry: {data['industry']}
- Stage: {data['stage']}

Valuation Results:
- Final Valuation: ${results['final_valuation']/1000000:.2f}M
- Berkus Valuation: ${results['berkus_valuation']/1000000:.2f}M
- ARR: ${results['arr']/1000000:.2f}M
- Growth Rate: {data['growth_rate']}%
- LTV/CAC: {results['ltv_cac_ratio']:.1f}
- Runway: {results['runway']:.1f} months
- Scorecard Scores: {results['scorecard_adjustments']}

Please include:
1. Valuation validity analysis
2. Industry positioning
3. Key strengths and improvement areas
4. Strategic priorities for next 6-12 months
5. Fundraising strategy and optimal round size
6. Key risks and mitigation strategies
7. Core KPIs and milestone recommendations
"""
        
        llm_response = self.call_llm_api(prompt, api_key)
        return llm_response
    
    def calculate_berkus_score(self, berkus_data):
        """버크스 방법으로 평가 (최대 $2.5M)"""
        scores = {}
        total = 0
        
        # 1. 건전한 아이디어 (Sound Idea)
        idea_score = min(100, berkus_data["idea_validation"] + berkus_data["market_research"] * 10)
        scores["sound_idea"] = self.berkus_max_values["sound_idea"] * (idea_score / 100)
        
        # 2. 프로토타입 (Prototype)
        prototype_score = 0
        if berkus_data["prototype_stage"] == "없음":
            prototype_score = 0
        elif berkus_data["prototype_stage"] == "컨셉/목업":
            prototype_score = 30
        elif berkus_data["prototype_stage"] == "작동 프로토타입":
            prototype_score = 60
        elif berkus_data["prototype_stage"] == "베타 버전":
            prototype_score = 80
        elif berkus_data["prototype_stage"] == "출시 버전":
            prototype_score = 100
        scores["prototype"] = self.berkus_max_values["prototype"] * (prototype_score / 100)
        
        # 3. 우수한 팀 (Quality Team)
        team_score = min(100, 
            min(berkus_data["team_experience"], 10) * 10 +  # 최대 10년까지만 가산
            berkus_data["domain_expertise"] * 15 +
            berkus_data["startup_experience"] * 15
        )
        scores["quality_team"] = self.berkus_max_values["quality_team"] * (team_score / 100)
        
        # 4. 전략적 관계 (Strategic Relationships)
        relationship_score = min(100,
            berkus_data["partnerships"] * 15 +
            berkus_data["advisors"] * 10 +
            berkus_data["pilot_customers"] * 25
        )
        scores["strategic_relationships"] = self.berkus_max_values["strategic_relationships"] * (relationship_score / 100)
        
        # 5. 제품 출시/판매 (Product Rollout)
        if berkus_data["sales_started"]:
            rollout_score = min(100, 50 + berkus_data["customer_validation"] * 10)
        else:
            rollout_score = berkus_data["launch_readiness"]
        scores["product_rollout"] = self.berkus_max_values["product_rollout"] * (rollout_score / 100)
        
        total = sum(scores.values())
        return total, scores
    
    def calculate_scorecard_valuation(self, scorecard_data, base_valuation):
        """스코어카드 방법으로 조정된 가치평가"""
        adjustments = {}
        
        # 각 요소별 조정 비율 계산 (0.5 ~ 1.5)
        adjustments["team"] = scorecard_data["team_strength"] / 100
        adjustments["market_size"] = scorecard_data["market_opportunity"] / 100
        adjustments["product"] = scorecard_data["product_stage"] / 100
        adjustments["competition"] = scorecard_data["competitive_advantage"] / 100
        adjustments["marketing"] = scorecard_data["marketing_channels"] / 100
        adjustments["need_for_funding"] = scorecard_data["funding_efficiency"] / 100
        adjustments["other"] = scorecard_data["other_factors"] / 100
        
        # 가중 평균 계산
        weighted_score = 0
        for factor, weight in self.scorecard_weights.items():
            # 각 점수를 0.5 ~ 1.5 범위로 변환 (50점이 1.0)
            adjusted_score = 0.5 + (adjustments[factor])
            weighted_score += adjusted_score * weight
        
        # 기본 가치평가에 조정 비율 적용
        adjusted_valuation = base_valuation * weighted_score
        
        return adjusted_valuation, adjustments, weighted_score
    
    def calculate_arr(self, monthly_revenue, revenue_type):
        """월 매출을 연간 반복 매출(ARR)로 변환"""
        if revenue_type == "구독형 (SaaS)":
            return monthly_revenue * 12
        elif revenue_type == "거래수수료형":
            return monthly_revenue * 12 * 0.8
        else:
            return monthly_revenue * 12 * 0.6
    
    def calculate_ltv(self, arpu, gross_margin, monthly_churn):
        """LTV 계산"""
        if monthly_churn == 0:
            monthly_churn = 0.01
        return arpu * (gross_margin / 100) / monthly_churn
    
    def calculate_cac(self, monthly_marketing, monthly_sales, new_customers):
        """CAC 계산"""
        if new_customers == 0:
            return 0
        return (monthly_marketing + monthly_sales) / new_customers
    
    def calculate_payback(self, cac, arpu, gross_margin):
        """Payback Period 계산 (개월)"""
        if arpu * (gross_margin / 100) == 0:
            return 999
        return cac / (arpu * (gross_margin / 100))
    
    def calculate_valuation(self, data, berkus_data, scorecard_data, use_revenue_multiple=True):
        """종합 가치평가 계산"""
        results = {}
        
        # 1. 버크스 방법 평가
        berkus_valuation, berkus_scores = self.calculate_berkus_score(berkus_data)
        results["berkus_valuation"] = berkus_valuation
        results["berkus_scores"] = berkus_scores
        
        # 2. 매출 기반 평가 (매출이 있는 경우)
        if data["monthly_revenue"] > 0 and use_revenue_multiple:
            # ARR 계산
            arr = self.calculate_arr(data["monthly_revenue"], data["revenue_type"])
            
            # 단위경제 계산
            ltv = self.calculate_ltv(data["arpu"], data["gross_margin"], data["monthly_churn"])
            cac = self.calculate_cac(data["monthly_marketing"], data["monthly_sales"], data["new_customers"])
            ltv_cac_ratio = ltv / cac if cac > 0 else 0
            payback = self.calculate_payback(cac, data["arpu"], data["gross_margin"])
            
            # 멀티플 결정
            multiples = self.industry_multiples[data["industry"]]
            growth_category = self.get_growth_category(data["growth_rate"])
            growth_adj = self.growth_adjustments[growth_category]
            
            # 기본 멀티플 선택
            if ltv_cac_ratio >= 3:
                base_multiple = multiples["high"]
            elif ltv_cac_ratio >= 1.5:
                base_multiple = multiples["mid"]
            else:
                base_multiple = multiples["low"]
            
            adjusted_multiple = base_multiple * growth_adj
            
            # 매출 기반 가치평가
            revenue_valuation = arr * adjusted_multiple
            
            results["arr"] = arr
            results["ltv"] = ltv
            results["cac"] = cac
            results["ltv_cac_ratio"] = ltv_cac_ratio
            results["payback"] = payback
            results["multiple"] = adjusted_multiple
        else:
            revenue_valuation = 0
            results["arr"] = 0
            results["ltv"] = 0
            results["cac"] = 0
            results["ltv_cac_ratio"] = 0
            results["payback"] = 0
            results["multiple"] = 0
        
        # 3. 기본 가치평가 결정 (버크스 vs 매출 기반)
        if revenue_valuation > berkus_valuation * 1.5:
            base_valuation = revenue_valuation
            valuation_method = "revenue_multiple"
        else:
            base_valuation = max(berkus_valuation, revenue_valuation)
            valuation_method = "berkus"
        
        # 4. 스코어카드 조정
        final_valuation, scorecard_adjustments, weighted_score = self.calculate_scorecard_valuation(
            scorecard_data, base_valuation
        )
        
        results["base_valuation"] = base_valuation
        results["final_valuation"] = final_valuation
        results["valuation_method"] = valuation_method
        results["scorecard_adjustments"] = scorecard_adjustments
        results["scorecard_multiplier"] = weighted_score
        
        # 5. 런웨이 계산
        results["runway"] = data["cash_balance"] / data["burn_rate"] if data["burn_rate"] > 0 else 999
        
        return results
    
    def get_growth_category(self, growth_rate):
        """성장률 카테고리 결정"""
        if growth_rate < 20:
            return "0-20%"
        elif growth_rate < 50:
            return "20-50%"
        elif growth_rate < 100:
            return "50-100%"
        elif growth_rate < 200:
            return "100-200%"
        else:
            return "200%+"
    
    def create_valuation_comparison_chart(self, results, language="ko"):
        """평가 방법별 비교 차트"""
        fig = go.Figure()
        
        methods = ["Berkus", "Revenue Multiple", "Scorecard Adjusted"]
        values = [
            results["berkus_valuation"],
            results["base_valuation"] if results["valuation_method"] == "revenue_multiple" else 0,
            results["final_valuation"]
        ]
        
        fig.add_trace(go.Bar(
            x=methods,
            y=values,
            text=[f"${v/1000000:.2f}M" for v in values],
            textposition="outside",
            marker_color=["lightblue", "lightgreen", "darkblue"]
        ))
        
        title = "평가 방법별 기업가치 비교" if language == "ko" else "Valuation by Method"
        fig.update_layout(
            title=title,
            yaxis_title="Valuation (USD)",
            showlegend=False,
            height=400
        )
        
        return fig
    
    def create_scorecard_radar_chart(self, adjustments, language="ko"):
        """스코어카드 요소별 점수 레이더 차트"""
        categories = list(adjustments.keys())
        if language == "ko":
            categories_display = ["팀", "시장규모", "제품", "경쟁력", "마케팅", "자금효율", "기타"]
        else:
            categories_display = ["Team", "Market", "Product", "Competition", "Marketing", "Funding", "Other"]
        
        values = [adjustments[cat] * 100 for cat in categories]
        
        fig = go.Figure(data=go.Scatterpolar(
            r=values,
            theta=categories_display,
            fill='toself'
        ))
        
        title = "스코어카드 평가 요소" if language == "ko" else "Scorecard Factors"
        fig.update_layout(
            polar=dict(
                radialaxis=dict(
                    visible=True,
                    range=[0, 100]
                )),
            showlegend=False,
            title=title
        )
        
        return fig

def create_ui():
    calculator = StartupValuationCalculator()
    
    def process_valuation(
        api_key, language,
        # 기본 정보
        company_name, founded_year, industry, stage, revenue_type,
        # 매출 정보
        monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
        retention_rate, new_customers, monthly_marketing, monthly_sales,
        # 재무 정보
        cash_balance, burn_rate,
        # 버크스 방법 입력
        idea_validation, market_research, prototype_stage, team_experience,
        domain_expertise, startup_experience, partnerships, advisors,
        pilot_customers, sales_started, customer_validation, launch_readiness,
        # 스코어카드 입력
        team_strength, market_opportunity, product_stage, competitive_advantage,
        marketing_channels, funding_efficiency, other_factors
    ):
        # 데이터 준비
        data = {
            "company_name": company_name,
            "founded_year": founded_year,
            "industry": industry,
            "stage": stage,
            "revenue_type": revenue_type,
            "monthly_revenue": monthly_revenue * 1000,
            "growth_rate": growth_rate,
            "arpu": arpu,
            "gross_margin": gross_margin,
            "monthly_churn": monthly_churn / 100,
            "retention_rate": retention_rate,
            "new_customers": new_customers,
            "monthly_marketing": monthly_marketing * 1000,
            "monthly_sales": monthly_sales * 1000,
            "cash_balance": cash_balance * 1000,
            "burn_rate": burn_rate * 1000
        }
        
        berkus_data = {
            "idea_validation": idea_validation,
            "market_research": market_research,
            "prototype_stage": prototype_stage,
            "team_experience": team_experience,
            "domain_expertise": domain_expertise,
            "startup_experience": startup_experience,
            "partnerships": partnerships,
            "advisors": advisors,
            "pilot_customers": pilot_customers,
            "sales_started": sales_started,
            "customer_validation": customer_validation,
            "launch_readiness": launch_readiness
        }
        
        scorecard_data = {
            "team_strength": team_strength,
            "market_opportunity": market_opportunity,
            "product_stage": product_stage,
            "competitive_advantage": competitive_advantage,
            "marketing_channels": marketing_channels,
            "funding_efficiency": funding_efficiency,
            "other_factors": other_factors
        }
        
        # 가치평가 계산
        use_revenue = monthly_revenue > 0
        results = calculator.calculate_valuation(data, berkus_data, scorecard_data, use_revenue)
        
        # 언어별 텍스트
        t = calculator.translations[language]
        
        # 결과 포맷팅
        if language == "ko":
            valuation_text = f"""
# 🚀 {company_name} {t['valuation_result']}

## 📊 종합 평가
- **{t['company_value']}**: ${results['final_valuation']/1000000:.2f}M
- **평가 방법**: {'매출 멀티플' if results['valuation_method'] == 'revenue_multiple' else '버크스 방법'} + 스코어카드 조정
- **스코어카드 조정 배수**: {results['scorecard_multiplier']:.2f}x

## 🎯 {t['berkus_score']} (최대 $2.5M)
- **총 평가액**: ${results['berkus_valuation']/1000000:.2f}M
- 건전한 아이디어: ${results['berkus_scores']['sound_idea']/1000:.0f}K
- 프로토타입: ${results['berkus_scores']['prototype']/1000:.0f}K
- 우수한 팀: ${results['berkus_scores']['quality_team']/1000:.0f}K
- 전략적 관계: ${results['berkus_scores']['strategic_relationships']/1000:.0f}K
- 제품 출시: ${results['berkus_scores']['product_rollout']/1000:.0f}K
"""
        else:
            valuation_text = f"""
# 🚀 {company_name} {t['valuation_result']}

## 📊 Summary
- **{t['company_value']}**: ${results['final_valuation']/1000000:.2f}M
- **Method**: {'Revenue Multiple' if results['valuation_method'] == 'revenue_multiple' else 'Berkus Method'} + Scorecard
- **Scorecard Multiplier**: {results['scorecard_multiplier']:.2f}x

## 🎯 {t['berkus_score']} (Max $2.5M)
- **Total**: ${results['berkus_valuation']/1000000:.2f}M
- Sound Idea: ${results['berkus_scores']['sound_idea']/1000:.0f}K
- Prototype: ${results['berkus_scores']['prototype']/1000:.0f}K
- Quality Team: ${results['berkus_scores']['quality_team']/1000:.0f}K
- Strategic Relationships: ${results['berkus_scores']['strategic_relationships']/1000:.0f}K
- Product Rollout: ${results['berkus_scores']['product_rollout']/1000:.0f}K
"""
        
        # 매출 기반 평가 추가 (매출이 있는 경우)
        if use_revenue and results['arr'] > 0:
            if language == "ko":
                valuation_text += f"""
## 💰 매출 기반 평가
- **ARR**: ${results['arr']/1000000:.2f}M
- **적용 멀티플**: {results['multiple']:.1f}x
- **LTV/CAC**: {results['ltv_cac_ratio']:.1f}x
- **Payback**: {results['payback']:.1f}개월
"""
            else:
                valuation_text += f"""
## 💰 Revenue-based Valuation
- **ARR**: ${results['arr']/1000000:.2f}M
- **Multiple**: {results['multiple']:.1f}x
- **LTV/CAC**: {results['ltv_cac_ratio']:.1f}x
- **Payback**: {results['payback']:.1f} months
"""
        
        # 재무 건전성
        if language == "ko":
            valuation_text += f"""
## 🏃 {t['financial_health']}
- **현금 런웨이**: {results['runway']:.1f}개월
- **월간 번레이트**: ${burn_rate}K
"""
        else:
            valuation_text += f"""
## 🏃 {t['financial_health']}
- **Cash Runway**: {results['runway']:.1f} months
- **Monthly Burn Rate**: ${burn_rate}K
"""
        
        # LLM 기반 전략적 분석 추가
        strategic_report = None
        if api_key and api_key.strip():
            strategic_report = calculator.generate_strategic_report(data, results, language, api_key)
            
            if strategic_report:
                if language == "ko":
                    valuation_text += f"""
## 🤖 AI 전략적 분석

{strategic_report}
"""
                else:
                    valuation_text += f"""
## 🤖 AI Strategic Analysis

{strategic_report}
"""
        
        # 차트 생성
        comparison_chart = calculator.create_valuation_comparison_chart(results, language)
        scorecard_chart = calculator.create_scorecard_radar_chart(results['scorecard_adjustments'], language)
        
        # 상세 테이블
        if language == "ko":
            methods_df = pd.DataFrame({
                "평가 방법": ["버크스 방법", "매출 멀티플", "스코어카드 조정", "최종 평가"],
                "평가액": [
                    f"${results['berkus_valuation']/1000000:.2f}M",
                    f"${results['base_valuation']/1000000:.2f}M" if results['valuation_method'] == 'revenue_multiple' else "N/A",
                    f"{results['scorecard_multiplier']:.2f}x",
                    f"${results['final_valuation']/1000000:.2f}M"
                ]
            })
        else:
            methods_df = pd.DataFrame({
                "Method": ["Berkus Method", "Revenue Multiple", "Scorecard Adjustment", "Final Valuation"],
                "Value": [
                    f"${results['berkus_valuation']/1000000:.2f}M",
                    f"${results['base_valuation']/1000000:.2f}M" if results['valuation_method'] == 'revenue_multiple' else "N/A",
                    f"{results['scorecard_multiplier']:.2f}x",
                    f"${results['final_valuation']/1000000:.2f}M"
                ]
            })
        
        return valuation_text, comparison_chart, scorecard_chart, methods_df
    
    # Gradio UI
    with gr.Blocks(title="Startup Valuation Calculator", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🦄 스타트업 가치평가 자동화 시스템 v3.5
        ### AI 기반 전략적 분석을 포함한 종합 평가 시스템
        """)
        
        # API 키와 언어 선택
        with gr.Row():
            api_key = gr.Textbox(
                label="Fireworks API Key (선택사항 - AI 분석용)",
                placeholder="AI 전략적 분석을 원하시면 API 키를 입력하세요",
                type="password"
            )
            language = gr.Radio(
                choices=[("한국어", "ko"), ("English", "en")],
                value="ko",
                label="Language / 언어",
                type="value"
            )
        
        with gr.Tab("기본 정보 / Basic Info"):
            with gr.Row():
                company_name = gr.Textbox(label="회사명 / Company Name", value="우리 스타트업")
                founded_year = gr.Slider(2000, 2025, value=2022, step=1, label="설립연도 / Founded Year")
            
            with gr.Row():
                industry = gr.Dropdown(
                    choices=list(calculator.industry_multiples.keys()),
                    value="SaaS - B2B",
                    label="산업 분류 / Industry"
                )
                stage = gr.Radio(
                    choices=["MVP/베타", "초기 매출", "성장 단계", "수익성 확보"],
                    value="초기 매출",
                    label="사업 단계 / Stage"
                )
            
            revenue_type = gr.Radio(
                choices=["구독형 (SaaS)", "거래수수료형", "일회성 판매"],
                value="구독형 (SaaS)",
                label="수익 모델 / Revenue Model"
            )
        
        with gr.Tab("버크스 평가 / Berkus Method"):
            gr.Markdown("### 💡 아이디어 검증 / Idea Validation")
            with gr.Row():
                idea_validation = gr.Slider(0, 100, value=70, step=10,
                                          label="아이디어 검증 수준 / Idea Validation Level (%)")
                market_research = gr.Slider(0, 10, value=5, step=1,
                                          label="시장 조사 깊이 / Market Research Depth (1-10)")
            
            gr.Markdown("### 🔧 프로토타입 / Prototype")
            prototype_stage = gr.Radio(
                choices=["없음", "컨셉/목업", "작동 프로토타입", "베타 버전", "출시 버전"],
                value="베타 버전",
                label="프로토타입 단계 / Prototype Stage"
            )
            
            gr.Markdown("### 👥 팀 역량 / Team Quality")
            with gr.Row():
                team_experience = gr.Slider(0, 30, value=5, step=1,
                                          label="팀 평균 경력(년) / Average Experience (years)")
                domain_expertise = gr.Slider(0, 5, value=3, step=1,
                                           label="도메인 전문성 / Domain Expertise (1-5)")
                startup_experience = gr.Slider(0, 5, value=2, step=1,
                                             label="스타트업 경험 / Startup Experience (1-5)")
            
            gr.Markdown("### 🤝 전략적 관계 / Strategic Relationships")
            with gr.Row():
                partnerships = gr.Number(label="전략적 파트너십 수 / Strategic Partnerships", value=2)
                advisors = gr.Number(label="고문/멘토 수 / Advisors/Mentors", value=3)
                pilot_customers = gr.Number(label="파일럿 고객 수 / Pilot Customers", value=5)
            
            gr.Markdown("### 🚀 제품 출시 / Product Rollout")
            with gr.Row():
                sales_started = gr.Checkbox(label="매출 발생 시작 / Sales Started", value=True)
                customer_validation = gr.Slider(0, 10, value=5, step=1,
                                              label="고객 검증 수준 / Customer Validation (1-10)")
                launch_readiness = gr.Slider(0, 100, value=80, step=10,
                                           label="출시 준비도 / Launch Readiness (%)")
        
        with gr.Tab("스코어카드 평가 / Scorecard"):
            gr.Markdown("### 각 요소를 동일 스테이지 평균 대비 평가 (50 = 평균)")
            gr.Markdown("### Rate each factor compared to same-stage average (50 = average)")
            
            team_strength = gr.Slider(0, 100, value=60, step=5,
                                    label="팀 역량 / Team Strength")
            market_opportunity = gr.Slider(0, 100, value=70, step=5,
                                         label="시장 기회 / Market Opportunity")
            product_stage = gr.Slider(0, 100, value=65, step=5,
                                    label="제품 완성도 / Product Maturity")
            competitive_advantage = gr.Slider(0, 100, value=55, step=5,
                                            label="경쟁 우위 / Competitive Advantage")
            marketing_channels = gr.Slider(0, 100, value=50, step=5,
                                         label="마케팅/판매 / Marketing & Sales")
            funding_efficiency = gr.Slider(0, 100, value=60, step=5,
                                         label="자금 효율성 / Funding Efficiency")
            other_factors = gr.Slider(0, 100, value=50, step=5,
                                    label="기타 요소 / Other Factors")
        
        with gr.Tab("매출 정보 / Revenue (Optional)"):
            gr.Markdown("### 💰 매출이 있는 경우만 입력 / Only if you have revenue")
            with gr.Row():
                monthly_revenue = gr.Number(label="월 매출 / Monthly Revenue ($K)", value=0)
                growth_rate = gr.Slider(0, 300, value=0, step=10,
                                       label="연간 성장률 / Annual Growth Rate (%)")
            
            with gr.Row():
                arpu = gr.Number(label="ARPU ($)", value=0)
                gross_margin = gr.Slider(0, 100, value=0, step=5,
                                        label="매출총이익률 / Gross Margin (%)")
            
            with gr.Row():
                retention_rate = gr.Slider(0, 100, value=0, step=5,
                                          label="고객 유지율 / Retention Rate (%)")
                monthly_churn = gr.Slider(0, 20, value=0, step=0.5,
                                         label="월 이탈률 / Monthly Churn (%)")
            
            with gr.Row():
                new_customers = gr.Number(label="월 신규 고객 / New Customers/Month", value=0)
                monthly_marketing = gr.Number(label="월 마케팅 비용 / Marketing Cost ($K)", value=0)
                monthly_sales = gr.Number(label="월 영업 비용 / Sales Cost ($K)", value=0)
        
        with gr.Tab("재무 현황 / Financials"):
            gr.Markdown("### 💸 현금 상황 / Cash Position ($K)")
            with gr.Row():
                cash_balance = gr.Number(label="현금 잔고 / Cash Balance ($K)", value=1000)
                burn_rate = gr.Number(label="월 번레이트 / Monthly Burn Rate ($K)", value=80)
        
        # 평가 실행 버튼
        evaluate_btn = gr.Button("🔍 가치평가 실행 / Run Valuation", variant="primary", size="lg")
        
        # 결과 출력
        with gr.Row():
            with gr.Column(scale=2):
                valuation_output = gr.Markdown(label="평가 결과 / Results")
            with gr.Column(scale=1):
                methods_table = gr.DataFrame(label="평가 방법 비교 / Method Comparison")
        
        with gr.Row():
            comparison_chart = gr.Plot(label="평가 방법 비교 / Valuation Comparison")
            scorecard_chart = gr.Plot(label="스코어카드 분석 / Scorecard Analysis")
        
        # 이벤트 연결
        evaluate_btn.click(
            process_valuation,
            inputs=[
                api_key, language,
                company_name, founded_year, industry, stage, revenue_type,
                monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
                retention_rate, new_customers, monthly_marketing, monthly_sales,
                cash_balance, burn_rate,
                idea_validation, market_research, prototype_stage, team_experience,
                domain_expertise, startup_experience, partnerships, advisors,
                pilot_customers, sales_started, customer_validation, launch_readiness,
                team_strength, market_opportunity, product_stage, competitive_advantage,
                marketing_channels, funding_efficiency, other_factors
            ],
            outputs=[valuation_output, comparison_chart, scorecard_chart, methods_table]
        )
        
        # 예시 데이터
        gr.Markdown("### 📝 예시 데이터 / Example Data")
        with gr.Row():
            gr.Button("초기 스타트업 / Early Startup").click(
                lambda: [
                    "", "ko", "테크 스타트업", 2023, "AI/딥테크", "MVP/베타", "구독형 (SaaS)",
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 500, 50,
                    80, 7, "베타 버전", 3, 4, 1, 1, 2, 3, False, 0, 70,
                    70, 65, 55, 60, 45, 50, 50
                ],
                outputs=[
                    api_key, language, company_name, founded_year, industry, stage, revenue_type,
                    monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
                    retention_rate, new_customers, monthly_marketing, monthly_sales,
                    cash_balance, burn_rate,
                    idea_validation, market_research, prototype_stage, team_experience,
                    domain_expertise, startup_experience, partnerships, advisors,
                    pilot_customers, sales_started, customer_validation, launch_readiness,
                    team_strength, market_opportunity, product_stage, competitive_advantage,
                    marketing_channels, funding_efficiency, other_factors
                ]
            )
            
            gr.Button("성장 단계 / Growth Stage").click(
                lambda: [
                    "", "en", "SaaS Corp", 2021, "SaaS - B2B", "성장 단계", "구독형 (SaaS)",
                    100, 150, 200, 75, 2, 90, 40, 30, 20, 2000, 120,
                    90, 9, "출시 버전", 8, 5, 3, 5, 5, 20, True, 8, 95,
                    85, 80, 75, 70, 65, 75, 60
                ],
                outputs=[
                    api_key, language, company_name, founded_year, industry, stage, revenue_type,
                    monthly_revenue, growth_rate, arpu, gross_margin, monthly_churn,
                    retention_rate, new_customers, monthly_marketing, monthly_sales,
                    cash_balance, burn_rate,
                    idea_validation, market_research, prototype_stage, team_experience,
                    domain_expertise, startup_experience, partnerships, advisors,
                    pilot_customers, sales_started, customer_validation, launch_readiness,
                    team_strength, market_opportunity, product_stage, competitive_advantage,
                    marketing_channels, funding_efficiency, other_factors
                ]
            )
    
    return demo

# 실행
if __name__ == "__main__":
    demo = create_ui()
    demo.launch(share=True)