app.py

# ============================================
# 📘 Vision LLM Agentic AI 프로젝트 견적 시스템
# - 보수적 MM 산정 / 오픈소스 중심
# - Phase별 상세 사이징
# - PDF/Excel 다운로드 기능
# - Hugging Face Spaces 최적화
# ============================================

import sys
import os
import math
import time
import warnings
warnings.filterwarnings("ignore")

# Hugging Face Spaces는 requirements.txt로 패키지 관리
import gradio as gr
import pandas as pd
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from fpdf import FPDF
import json
from datetime import datetime

print("✅ 패키지 로드 완료!\n" + "="*70)

# ============================================
# 💰 금액 산출 기준 (명확히 정의)
# ============================================

CURRENCY_INFO = {
    "base": "KRW",
    "unit": "억원",
    "display_factor": 100_000_000,
}

# 인건비 (원화 기준)
LABOR_RATES = {
    "Senior_Engineer": 18_000_000,
    "Mid_Engineer": 15_000_000,
    "Junior_Engineer": 12_000_000,
    "Architect": 20_000_000,
    "Average": 15_000_000,
}

LABOR_COST_PER_MM = LABOR_RATES["Average"]

# GPU 단가 (원화 기준)
GPU_COSTS_KRW = {
    'A100_80GB': 4_000_000_000,
    'H100_80GB': 6_000_000_000,
    'A100_40GB': 2_500_000_000,
    'L40S': 1_500_000_000,
}

GPU_COST = {k: v / CURRENCY_INFO['display_factor'] for k, v in GPU_COSTS_KRW.items()}

# 서버 단가
SERVER_COSTS_KRW = {
    'CPU_High_End': 50_000_000,
    'CPU_Mid_Range': 30_000_000,
    'RAM_256GB': 10_000_000,
    'RAM_512GB': 20_000_000,
}

STORAGE_COST_PER_TB = 2_000_000
OSS_SETUP_COST_PER_MM = 3_000_000

EXCHANGE_RATE_INFO = {
    "USD_to_KRW": 1330,
    "note": "GPU 가격은 미국 시장가를 환율 적용하여 산정"
}

# 보수적 안전계수
SAFETY_FACTOR = 1.4
GPU_EFFICIENCY = 0.65
PARALLEL_EFFICIENCY = 0.70
OSS_LABOR_MULTIPLIER = 1.5

# ============================================
# Value Chain Phase 정의
# ============================================

VALUE_CHAIN_PHASES = {
    "Phase1_DataPrep": {
        "name": "Phase 1: 데이터 준비 및 기반 구축",
        "description": "문서 수집, 전처리, 메타데이터, 온톨로지 설계",
        "base_mm_ratio": 0.39,
        "roles": ["Data Engineer", "Data Architect", "Ontology Engineer"],
        "oss_stack": [
            "PyMuPDF (문서 파싱)",
            "OpenCV (이미지 처리)",
            "LayoutParser (표 인식)",
            "spaCy (NLP)",
            "PostgreSQL (메타DB)",
            "Neo4j (그래프DB)",
            "Apache Airflow (워크플로)",
            "DVC (데이터 버전관리)"
        ]
    },
    "Phase2_Training": {
        "name": "Phase 2: 모델 학습 및 최적화",
        "description": "Vision LLM Fine-Tuning, Q-LoRA, Validation",
        "base_mm_ratio": 0.23,
        "roles": ["ML Engineer", "AI Architect", "Research Engineer"],
        "oss_stack": [
            "PyTorch (딥러닝)",
            "PEFT/LoRA (효율적 학습)",
            "Hugging Face Transformers",
            "Albumentations (증강)",
            "InternVL 3.5 (Vision LLM)",
            "Unsloth (학습 가속)",
            "MLflow (실험 추적)",
            "Weights & Biases (모니터링)"
        ]
    },
    "Phase3_AgenticDev": {
        "name": "Phase 3: Agentic AI 애플리케이션 개발",
        "description": "Agent 설계, Workflow, Tool 연동, RAG",
        "base_mm_ratio": 0.17,
        "roles": ["AI Architect", "Backend Engineer", "ML Engineer"],
        "oss_stack": [
            "LangGraph (Agent 프레임워크)",
            "LangChain (LLM 체인)",
            "CrewAI (Multi-Agent)",
            "Qdrant (Vector DB)",
            "FAISS (벡터 검색)",
            "Redis (Memory)",
            "FastAPI (API)",
            "n8n (워크플로 자동화)"
        ]
    },
    "Phase4_Deployment": {
        "name": "Phase 4: 배포·운영 및 지속 개선",
        "description": "Docker/K8s 배포, 모니터링, 재학습 자동화",
        "base_mm_ratio": 0.21,
        "roles": ["DevOps Engineer", "MLOps Engineer", "SRE"],
        "oss_stack": [
            "Docker (컨테이너)",
            "Kubernetes (오케스트레이션)",
            "Prometheus (메트릭)",
            "Grafana (시각화)",
            "ELK Stack (로그)",
            "ArgoCD (GitOps)",
            "Kubeflow (ML 파이프라인)",
            "GitLab CI/CD"
        ]
    }
}

# ============================================
# Function Points
# ============================================

FP_COEFFICIENTS = {
    "A-01": 0.00003, "A-02": 0.000015, "A-03": 0.00004, "A-04": 0.00008,
    "A-05": 0.00006, "A-06": 0.00005, "A-07": 0.000055,
    "B-01": 0.00004, "B-02": 0.00003, "B-03": 0.00005, "B-04": 0.00004,
    "C-01": 0.00005, "C-02": 0.00007, "C-03": 0.00004, "C-04": 0.00003,
    "D-01": 0.00009, "D-02": 0.00006, "D-03": 0.00015, "D-04": 0.00006, "D-05": 0.00004,
    "F-01": 0.00005, "F-02": 0.00008, "F-03": 0.00007, "F-04": 0.00009, "F-05": 0.00007,
    "G-01": 0.00008, "G-02": 0.00006, "G-03": 0.00004, "G-04": 0.00007,
    "H-01": 0.00004, "H-02": 0.00005, "H-03": 0.00008, "H-04": 0.00003,
}

FP_TO_PHASE = {
    "Phase1_DataPrep": ["A-01", "A-02", "A-03", "A-04", "A-05", "A-06", "A-07",
                        "B-01", "B-02", "B-03", "B-04", "C-01", "C-02", "C-03", "C-04"],
    "Phase2_Training": ["D-01", "D-02", "D-03", "D-04", "D-05"],
    "Phase3_AgenticDev": ["F-01", "F-02", "F-03", "F-04", "F-05"],
    "Phase4_Deployment": ["G-01", "G-02", "G-03", "G-04", "H-01", "H-02", "H-03", "H-04"]
}

# ============================================
# 핵심 계산 함수
# ============================================

def calculate_phase_mm(phase_id, N_pages, doc_complexity, language_mix, 
                       table_ratio, image_quality, model_size, 
                       training_epochs, agent_complexity):
    """Phase별 MM 계산"""
    
    fps = FP_TO_PHASE.get(phase_id, [])
    total_mm = 0.0
    fp_details = []
    
    if N_pages <= 10000:
        scale_factor = 1.0
    elif N_pages <= 100000:
        scale_factor = 4.5
    else:
        scale_factor = 12.0
    
    for fp in fps:
        coeff = FP_COEFFICIENTS.get(fp, 0.00005)
        base_mm = coeff * N_pages * scale_factor
        
        if phase_id == "Phase1_DataPrep":
            weight = (doc_complexity * language_mix * 
                     (1 + table_ratio) * image_quality)
            if fp in ["A-04", "A-05"]:
                weight *= (1 + table_ratio*0.5)
                
        elif phase_id == "Phase2_Training":
            weight = model_size * (1 + training_epochs/10) * image_quality
            if fp == "D-03":
                weight *= 1.8
                
        elif phase_id == "Phase3_AgenticDev":
            weight = agent_complexity * doc_complexity
            
        else:
            weight = (doc_complexity + agent_complexity) / 2
        
        mm = base_mm * weight * OSS_LABOR_MULTIPLIER * SAFETY_FACTOR
        total_mm += mm
        
        fp_details.append({
            "FP": fp,
            "Base_MM": round(base_mm, 3),
            "Weight": round(weight, 2),
            "Final_MM": round(mm, 2)
        })
    
    return total_mm, fp_details

def calculate_hardware(phase_id, N_pages, model_size, training_epochs, 
                       deployment_type, sla_level):
    """Phase별 HW 사이징"""
    
    hw = {}
    
    if phase_id == "Phase1_DataPrep":
        base_gpu = max(2, math.ceil(N_pages / 5000 * SAFETY_FACTOR))
        hw["Preprocess_GPU"] = min(base_gpu, 8)
        hw["GPU_Type"] = "L40S"
        hw["CPU_Cores"] = 16 * hw["Preprocess_GPU"]
        hw["RAM_GB"] = 64 * hw["Preprocess_GPU"]
        hw["Storage_TB"] = round(max(10, N_pages * 0.5 / 1000000), 1)
        
    elif phase_id == "Phase2_Training":
        base_gpu = max(4, math.ceil(N_pages * training_epochs / 3000 * model_size * SAFETY_FACTOR))
        hw["Training_GPU"] = base_gpu
        hw["GPU_Type"] = "A100_80GB"
        hw["CPU_Cores"] = 32 * hw["Training_GPU"]
        hw["RAM_GB"] = 128 * hw["Training_GPU"]
        hw["Storage_TB"] = round(max(50, N_pages * training_epochs * 2.0 / 1000000), 1)
        
    elif phase_id == "Phase3_AgenticDev":
        hw["Dev_GPU"] = max(2, math.ceil(model_size * 2))
        hw["GPU_Type"] = "A100_40GB"
        hw["VectorDB_Instances"] = max(2, math.ceil(N_pages / 100000))
        hw["CPU_Cores"] = 32
        hw["RAM_GB"] = 256
        hw["Storage_TB"] = round(max(20, N_pages * 1.0 / 1000000), 1)
        
    else:
        qps_estimate = N_pages / 10000
        base_gpu = max(2, math.ceil(qps_estimate * sla_level * SAFETY_FACTOR))
        hw["Inference_GPU"] = base_gpu
        hw["GPU_Type"] = "A100_80GB"
        hw["K8s_Nodes"] = max(3, math.ceil(base_gpu / 2))
        hw["CPU_Cores"] = 64
        hw["RAM_GB"] = 512
        hw["Storage_TB"] = round(max(100, N_pages * 2.0 / 1000000), 1)
    
    return hw

def estimate_cost(hw, mm, phase_id):
    """비용 산정"""
    
    labor_cost_krw = mm * LABOR_COST_PER_MM
    labor_cost = labor_cost_krw / CURRENCY_INFO['display_factor']
    
    gpu_cost = 0
    if "Training_GPU" in hw:
        gpu_type = hw.get("GPU_Type", "A100_80GB")
        gpu_cost = hw["Training_GPU"] * GPU_COST.get(gpu_type, 40.0)
    elif "Preprocess_GPU" in hw:
        gpu_type = hw.get("GPU_Type", "L40S")
        gpu_cost = hw["Preprocess_GPU"] * GPU_COST.get(gpu_type, 15.0)
    elif "Inference_GPU" in hw:
        gpu_type = hw.get("GPU_Type", "A100_80GB")
        gpu_cost = hw["Inference_GPU"] * GPU_COST.get(gpu_type, 40.0)
    elif "Dev_GPU" in hw:
        gpu_type = hw.get("GPU_Type", "A100_40GB")
        gpu_cost = hw["Dev_GPU"] * GPU_COST.get(gpu_type, 25.0)
    
    server_cost_krw = 0
    if hw.get("CPU_Cores", 0) >= 32:
        server_cost_krw += SERVER_COSTS_KRW['CPU_High_End']
    elif hw.get("CPU_Cores", 0) >= 16:
        server_cost_krw += SERVER_COSTS_KRW['CPU_Mid_Range']
    
    if hw.get("RAM_GB", 0) >= 512:
        server_cost_krw += SERVER_COSTS_KRW['RAM_512GB']
    elif hw.get("RAM_GB", 0) >= 256:
        server_cost_krw += SERVER_COSTS_KRW['RAM_256GB']
    
    server_cost = server_cost_krw / CURRENCY_INFO['display_factor']
    
    storage_cost_krw = 0
    if "Storage_TB" in hw:
        storage_cost_krw = hw["Storage_TB"] * STORAGE_COST_PER_TB
    storage_cost = storage_cost_krw / CURRENCY_INFO['display_factor']
    
    oss_setup_cost_krw = mm * OSS_SETUP_COST_PER_MM
    oss_setup_cost = oss_setup_cost_krw / CURRENCY_INFO['display_factor']
    
    hw_total = gpu_cost + server_cost + storage_cost
    infra_cost = hw_total * 0.3
    
    total_cost = labor_cost + gpu_cost + server_cost + storage_cost + oss_setup_cost + infra_cost
    
    return {
        "Labor": round(labor_cost, 1),
        "GPU": round(gpu_cost, 1),
        "Server": round(server_cost, 1),
        "Storage": round(storage_cost, 1),
        "OSS_Setup": round(oss_setup_cost, 1),
        "Infrastructure": round(infra_cost, 1),
        "Total": round(total_cost, 1),
    }

# ============================================
# 메인 견적 함수
# ============================================

def run_estimation(N_pages, doc_complexity, language_mix, table_ratio,
                   image_quality, model_size, training_epochs, 
                   agent_complexity, deployment_type, sla_level, 
                   security_level):
    """전체 견적 실행"""
    
    try:
        if N_pages < 1000:
            return ("❌ 문서 수는 최소 1,000장 이상이어야 합니다.",) + (None,) * 7
        
        results = {}
        total_mm = 0
        
        phase_ids = ["Phase1_DataPrep", "Phase2_Training", "Phase3_AgenticDev", "Phase4_Deployment"]
        
        for phase_id in phase_ids:
            phase_info = VALUE_CHAIN_PHASES[phase_id]
            
            mm, fp_details = calculate_phase_mm(
                phase_id, N_pages, doc_complexity, language_mix,
                table_ratio/100, image_quality, model_size,
                training_epochs, agent_complexity
            )
            
            if phase_id == "Phase4_Deployment":
                mm *= (sla_level * security_level)
            
            mm *= deployment_type
            total_mm += mm
            
            hw = calculate_hardware(
                phase_id, N_pages, model_size, training_epochs,
                deployment_type, sla_level
            )
            
            cost = estimate_cost(hw, mm, phase_id)
            
            results[phase_id] = {
                "name": phase_info["name"],
                "mm": round(mm, 1),
                "hw": hw,
                "cost": cost,
                "fp_details": fp_details,
                "oss_stack": phase_info["oss_stack"]
            }
        
        duration_months = (
            results["Phase1_DataPrep"]["mm"] / 8 +
            max(results["Phase2_Training"]["mm"] / 10,
                results["Phase3_AgenticDev"]["mm"] / 6) * PARALLEL_EFFICIENCY +
            results["Phase4_Deployment"]["mm"] / 8
        )
        duration_months = math.ceil(duration_months * 1.2)
        
        summary = generate_summary(results, total_mm, duration_months, N_pages)
        phase_chart = create_phase_chart(results)
        cost_chart = create_cost_breakdown(results)
        timeline_chart = create_timeline(results, duration_months)
        hw_table = create_hw_table(results)
        oss_table = create_oss_table(results)
        
        pdf_path = generate_pdf(results, total_mm, duration_months, N_pages)
        excel_path = generate_excel(results, total_mm, duration_months, N_pages)
        
        return summary, phase_chart, cost_chart, timeline_chart, hw_table, oss_table, pdf_path, excel_path
        
    except Exception as e:
        import traceback
        error_detail = traceback.format_exc()
        error_msg = f"❌ 오류 발생: {str(e)}\n\n상세:\n{error_detail}"
        return (error_msg,) + (None,) * 7

def generate_summary(results, total_mm, duration_months, N_pages):
    """요약 생성"""
    
    total_cost = sum(r["cost"]["Total"] for r in results.values())
    total_labor = sum(r["cost"]["Labor"] for r in results.values())
    total_gpu = sum(r["cost"]["GPU"] for r in results.values())
    total_oss = sum(r["cost"]["OSS_Setup"] for r in results.values())
    
    summary = f"""
# 📊 Vision LLM Agentic AI 프로젝트 견적서

## 💰 금액 산출 기준
- **기준 통화**: 원화 (KRW)
- **표시 단위**: 억원 (1억 = 100,000,000원)
- **환율 참조**: USD 1,330원 (2024년 11월 기준)

### 단가 정보
- **인건비**: 1,500만원/MM (Man-Month)
- **GPU 단가**: A100 80GB 40억원, H100 80GB 60억원
- **OSS 구축비**: 300만원/MM
- **스토리지**: 200만원/TB

## 프로젝트 개요
- **처리 대상**: {N_pages:,}장
- **총 소요 인력**: {total_mm:.1f} MM
- **예상 기간**: {duration_months}개월
- **총 예상 비용**: {total_cost:.1f}억원 ({int(total_cost * 100_000_000):,}원)

## Phase별 요약

### {results["Phase1_DataPrep"]["name"]}
- 인력: {results["Phase1_DataPrep"]["mm"]:.1f} MM
- 비용: {results["Phase1_DataPrep"]["cost"]["Total"]:.1f}억원
- 주요 HW: {results["Phase1_DataPrep"]["hw"].get("GPU_Type", "N/A")} × {results["Phase1_DataPrep"]["hw"].get("Preprocess_GPU", 0)}대

### {results["Phase2_Training"]["name"]}
- 인력: {results["Phase2_Training"]["mm"]:.1f} MM
- 비용: {results["Phase2_Training"]["cost"]["Total"]:.1f}억원
- 주요 HW: {results["Phase2_Training"]["hw"].get("GPU_Type", "N/A")} × {results["Phase2_Training"]["hw"].get("Training_GPU", 0)}대

### {results["Phase3_AgenticDev"]["name"]}
- 인력: {results["Phase3_AgenticDev"]["mm"]:.1f} MM
- 비용: {results["Phase3_AgenticDev"]["cost"]["Total"]:.1f}억원
- 주요 HW: {results["Phase3_AgenticDev"]["hw"].get("GPU_Type", "N/A")} × {results["Phase3_AgenticDev"]["hw"].get("Dev_GPU", 0)}대

### {results["Phase4_Deployment"]["name"]}
- 인력: {results["Phase4_Deployment"]["mm"]:.1f} MM
- 비용: {results["Phase4_Deployment"]["cost"]["Total"]:.1f}억원
- 주요 HW: {results["Phase4_Deployment"]["hw"].get("GPU_Type", "N/A")} × {results["Phase4_Deployment"]["hw"].get("Inference_GPU", 0)}대

## 비용 구성
- **인건비**: {total_labor:.1f}억원 ({total_labor/total_cost*100:.1f}%)
- **GPU**: {total_gpu:.1f}억원 ({total_gpu/total_cost*100:.1f}%)
- **OSS 구축**: {total_oss:.1f}억원 ({total_oss/total_cost*100:.1f}%)
- **기타 인프라**: {sum(r["cost"]["Infrastructure"] for r in results.values()):.1f}억원

---
💡 **참고사항**
- 본 견적은 보수적 관점에서 산정 (안전계수 1.4)
- 오픈소스 기반으로 상용 대비 1.5배 인력 반영
- 실제 프로젝트 진행 시 ±15% 조정 가능
"""
    
    return summary

# ============================================
# PDF 생성 함수
# ============================================

def generate_pdf(results, total_mm, duration_months, N_pages):
    """PDF 견적서 생성"""
    
    try:
        pdf = FPDF(orientation='P', unit='mm', format='A4')
        pdf.add_page()
        pdf.set_margins(25, 15, 25)
        pdf.set_auto_page_break(auto=True, margin=15)
        
        # 기본 폰트 사용 (한글 지원 제한적)
        pdf.set_font('Arial', '', 10)
        
        # 제목
        pdf.set_font('Arial', 'B', 16)
        pdf.cell(0, 10, 'Vision LLM Agentic AI Estimate', ln=1, align='C')
        pdf.ln(3)
        
        pdf.set_font('Arial', '', 9)
        pdf.cell(0, 5, f'Date: {datetime.now().strftime("%Y-%m-%d")}', ln=1, align='R')
        pdf.ln(5)
        
        # 1. 금액 기준
        pdf.set_font('Arial', 'B', 11)
        pdf.cell(0, 7, '1. Cost Basis', ln=1)
        pdf.set_font('Arial', '', 9)
        
        pdf.cell(0, 5, 'Currency: KRW (Korean Won)', ln=1)
        pdf.cell(0, 5, 'Unit: 100M KRW', ln=1)
        pdf.cell(0, 5, 'Labor: 15M KRW/MM', ln=1)
        pdf.cell(0, 5, 'GPU A100 80GB: 4B KRW', ln=1)
        pdf.cell(0, 5, 'OSS Setup: 3M KRW/MM', ln=1)
        pdf.ln(3)
        
        # 2. 개요
        pdf.set_font('Arial', 'B', 11)
        pdf.cell(0, 7, '2. Project Overview', ln=1)
        pdf.set_font('Arial', '', 9)
        
        total_cost = sum(r["cost"]["Total"] for r in results.values())
        
        pdf.cell(0, 5, f'Documents: {N_pages:,} pages', ln=1)
        pdf.cell(0, 5, f'Manpower: {total_mm:.1f} MM', ln=1)
        pdf.cell(0, 5, f'Duration: {duration_months} months', ln=1)
        pdf.cell(0, 5, f'Total Cost: {total_cost:.1f}B KRW', ln=1)
        pdf.ln(3)
        
        # 3. Phase별 상세
        pdf.set_font('Arial', 'B', 11)
        pdf.cell(0, 7, '3. Phase Details', ln=1)
        pdf.ln(2)
        
        for i, (phase_id, data) in enumerate(results.items(), 1):
            pdf.set_font('Arial', 'B', 10)
            phase_name = f"Phase {i}"
            pdf.cell(0, 6, phase_name, ln=1)
            
            pdf.set_font('Arial', '', 9)
            pdf.cell(0, 4, f'  MM: {data["mm"]:.1f}', ln=1)
            pdf.cell(0, 4, f'  Cost: {data["cost"]["Total"]:.1f}B KRW', ln=1)
            pdf.cell(0, 4, f'  Labor: {data["cost"]["Labor"]:.1f}B', ln=1)
            pdf.cell(0, 4, f'  GPU: {data["cost"]["GPU"]:.1f}B', ln=1)
            pdf.ln(1)
        
        pdf.ln(3)
        
        # 4. HW 요약
        pdf.add_page()
        pdf.set_font('Arial', 'B', 11)
        pdf.cell(0, 7, '4. Hardware Summary', ln=1)
        pdf.ln(2)
        
        for phase_id, data in results.items():
            hw = data["hw"]
            pdf.set_font('Arial', '', 9)
            
            if "Training_GPU" in hw:
                pdf.cell(0, 4, f'Training: {hw["GPU_Type"]} x{hw["Training_GPU"]}', ln=1)
            elif "Preprocess_GPU" in hw:
                pdf.cell(0, 4, f'Preprocess: {hw["GPU_Type"]} x{hw["Preprocess_GPU"]}', ln=1)
            elif "Inference_GPU" in hw:
                pdf.cell(0, 4, f'Inference: {hw["GPU_Type"]} x{hw["Inference_GPU"]}', ln=1)
            elif "Dev_GPU" in hw:
                pdf.cell(0, 4, f'Dev: {hw["GPU_Type"]} x{hw["Dev_GPU"]}', ln=1)
            
            pdf.cell(0, 4, f'  CPU: {hw.get("CPU_Cores", 0)} cores', ln=1)
            pdf.cell(0, 4, f'  RAM: {hw.get("RAM_GB", 0)} GB', ln=1)
            pdf.cell(0, 4, f'  Storage: {hw.get("Storage_TB", 0)} TB', ln=1)
            pdf.ln(1)
        
        timestamp = int(time.time())
        pdf_path = f'/tmp/Estimate_{timestamp}.pdf'
        pdf.output(pdf_path)
        
        return pdf_path
        
    except Exception as e:
        print(f"PDF generation error: {e}")
        return None

# ============================================
# Excel 생성 함수
# ============================================

def generate_excel(results, total_mm, duration_months, N_pages):
    """Excel 견적서 생성"""
    
    try:
        timestamp = int(time.time())
        excel_path = f'/tmp/Estimate_{timestamp}.xlsx'
        
        with pd.ExcelWriter(excel_path, engine='xlsxwriter') as writer:
            
            # 1. 요약
            total_cost = sum(r["cost"]["Total"] for r in results.values())
            summary_data = {
                'Item': ['Documents', 'Manpower', 'Duration', 'Total Cost (100M KRW)', 'Total Cost (KRW)'],
                'Value': [
                    f'{N_pages:,} pages',
                    f'{total_mm:.1f} MM',
                    f'{duration_months} months',
                    f'{total_cost:.1f}',
                    f'{int(total_cost * 100_000_000):,}'
                ]
            }
            pd.DataFrame(summary_data).to_excel(writer, sheet_name='Summary', index=False)
            
            # 2. Phase별 상세
            phase_data = []
            for phase_id, data in results.items():
                phase_data.append({
                    'Phase': data["name"].split(":")[1].strip(),
                    'MM': round(data["mm"], 1),
                    'Labor (100M)': round(data["cost"]["Labor"], 1),
                    'GPU (100M)': round(data["cost"]["GPU"], 1),
                    'OSS Setup (100M)': round(data["cost"]["OSS_Setup"], 1),
                    'Total (100M)': round(data["cost"]["Total"], 1)
                })
            pd.DataFrame(phase_data).to_excel(writer, sheet_name='Phase Details', index=False)
            
            # 3. HW
            hw_data = []
            for phase_id, data in results.items():
                hw = data["hw"]
                hw_row = {'Phase': data["name"].split(":")[1].strip()}
                hw_row.update(hw)
                hw_data.append(hw_row)
            pd.DataFrame(hw_data).to_excel(writer, sheet_name='Hardware', index=False)
            
            # 4. OSS
            oss_data = []
            for phase_id, data in results.items():
                for oss in data["oss_stack"]:
                    oss_data.append({
                        'Phase': data["name"].split(":")[1].strip(),
                        'Open Source': oss
                    })
            pd.DataFrame(oss_data).to_excel(writer, sheet_name='Open Source', index=False)
        
        return excel_path
        
    except Exception as e:
        print(f"Excel generation error: {e}")
        return None

# ============================================
# 시각화 함수
# ============================================

def create_phase_chart(results):
    """Phase별 비교 차트"""
    
    names = [results[p]["name"].split(":")[1].strip() for p in results.keys()]
    mms = [results[p]["mm"] for p in results.keys()]
    costs = [results[p]["cost"]["Total"] for p in results.keys()]
    
    fig = make_subplots(
        rows=1, cols=2,
        subplot_titles=('Phase Manpower (MM)', 'Phase Cost (100M KRW)'),
        specs=[[{'type':'bar'}, {'type':'bar'}]]
    )
    
    fig.add_trace(
        go.Bar(x=names, y=mms, text=[f"{m:.1f}" for m in mms],
               textposition='auto', marker_color='#3498db'),
        row=1, col=1
    )
    
    fig.add_trace(
        go.Bar(x=names, y=costs, text=[f"{c:.1f}" for c in costs],
               textposition='auto', marker_color='#e74c3c'),
        row=1, col=2
    )
    
    fig.update_layout(height=400, showlegend=False, title_text="Phase Comparison", title_x=0.5)
    return fig

def create_cost_breakdown(results):
    """비용 구성 차트"""
    
    categories = []
    values = []
    
    for phase_id, data in results.items():
        name = data["name"].split(":")[1].strip()
        categories.append(f"{name}\nLabor")
        values.append(data["cost"]["Labor"])
        categories.append(f"{name}\nGPU")
        values.append(data["cost"]["GPU"])
    
    fig = go.Figure(data=[go.Pie(
        labels=categories,
        values=values,
        hole=.4,
        textinfo='label+percent',
        textposition='outside'
    )])
    
    fig.update_layout(title_text="Cost Breakdown", height=500)
    return fig

def create_timeline(results, duration_months):
    """타임라인 차트"""
    
    phase_durations = {}
    start = 0
    
    p1_dur = math.ceil(results["Phase1_DataPrep"]["mm"] / 8)
    phase_durations["Phase1_DataPrep"] = (start, p1_dur)
    start += p1_dur
    
    p2_dur = math.ceil(results["Phase2_Training"]["mm"] / 10)
    p3_dur = math.ceil(results["Phase3_AgenticDev"]["mm"] / 6)
    parallel = max(p2_dur, p3_dur)
    
    phase_durations["Phase2_Training"] = (start, p2_dur)
    phase_durations["Phase3_AgenticDev"] = (start, p3_dur)
    start += parallel
    
    p4_dur = math.ceil(results["Phase4_Deployment"]["mm"] / 8)
    phase_durations["Phase4_Deployment"] = (start, p4_dur)
    
    fig = go.Figure()
    colors = ['#3498db', '#e74c3c', '#2ecc71', '#f39c12']
    
    for i, (phase_id, (s, d)) in enumerate(phase_durations.items()):
        name = results[phase_id]["name"].split(":")[1].strip()
        fig.add_trace(go.Bar(
            y=[name], x=[d], base=s, orientation='h',
            marker=dict(color=colors[i]), text=f"{d}mo",
            textposition='inside', name=name
        ))
    
    fig.update_layout(
        title="Project Timeline", xaxis_title="Months", yaxis_title="Phase",
        barmode='overlay', height=400, showlegend=False
    )
    return fig

def create_hw_table(results):
    """HW 테이블"""
    
    rows = []
    for phase_id, data in results.items():
        row = {"Phase": data["name"].split(":")[1].strip()}
        row.update(data["hw"])
        rows.append(row)
    return pd.DataFrame(rows)

def create_oss_table(results):
    """OSS 테이블"""
    
    rows = []
    for phase_id, data in results.items():
        name = data["name"].split(":")[1].strip()
        for i, oss in enumerate(data["oss_stack"]):
            rows.append({
                "Phase": name if i == 0 else "",
                "No": i+1,
                "Open Source": oss
            })
    return pd.DataFrame(rows)

# ============================================
# Gradio UI
# ============================================

EXAMPLES = [
    [10000, 0.7, 0.8, 20, 0.8, 0.8, 3, 0.8, 1.0, 1.0, 1.0],
    [50000, 1.0, 1.0, 40, 1.0, 1.0, 3, 1.0, 1.0, 1.0, 1.0],
    [100000, 1.3, 1.3, 60, 1.0, 1.0, 5, 1.3, 1.0, 1.2, 1.3],
    [500000, 1.6, 1.5, 80, 1.3, 1.3, 5, 1.6, 1.4, 1.5, 1.6],
]

with gr.Blocks(title="Vision LLM Agentic AI 견적", theme=gr.themes.Soft()) as demo:
    
    gr.Markdown("""
    # 📘 Vision LLM 기반 Agentic AI 프로젝트 견적 시스템
    
    **보수적 견적 / 오픈소스 중심 / Phase별 상세 분석 / PDF·Excel 다운로드**
    
    💰 **금액 기준**: 원화(KRW), 단위: 억원 | 환율: USD 1,330원
    """)
    
    with gr.Tab("📋 파라미터 입력"):
        
        gr.Markdown("## 1️⃣ 프로젝트 규모")
        N_pages = gr.Number(label="📄 문서 페이지 수", value=10000)
        
        gr.Markdown("## 2️⃣ 문서 특성")
        with gr.Row():
            doc_complexity = gr.Slider(0.7, 1.6, value=1.0, step=0.1,
                label="📊 문서 복잡도", info="0.7=단순, 1.0=보통, 1.3=복잡, 1.6=매우복잡")
            language_mix = gr.Slider(0.8, 1.5, value=1.0, step=0.1,
                label="🌐 언어 복잡도", info="0.8=단일, 1.0=이중, 1.3=다국어")
        
        with gr.Row():
            table_ratio = gr.Slider(0, 100, value=40, step=5,
                label="📋 표 비율 (%)")
            image_quality = gr.Slider(0.8, 1.6, value=1.0, step=0.1,
                label="🖼️ 이미지 품질", info="0.8=고, 1.0=중, 1.3=저")
        
        gr.Markdown("## 3️⃣ 모델 및 학습")
        with gr.Row():
            model_size = gr.Slider(0.8, 1.6, value=1.0, step=0.1,
                label="🤖 모델 크기", info="0.8=소형, 1.0=중형, 1.3=대형")
            training_epochs = gr.Slider(1, 10, value=3, step=1,
                label="🔄 학습 Epoch")
        
        gr.Markdown("## 4️⃣ Agentic AI 및 배포")
        with gr.Row():
            agent_complexity = gr.Slider(0.8, 1.6, value=1.0, step=0.1,
                label="🎯 Agent 복잡도", info="0.8=기본, 1.0=표준, 1.3=고급")
            deployment_type = gr.Slider(0.9, 1.4, value=1.0, step=0.1,
                label="🏗️ 배포 환경", info="0.9=Cloud, 1.0=On-Prem, 1.4=Air-Gap")
        
        gr.Markdown("## 5️⃣ 운영 요구사항")
        with gr.Row():
            sla_level = gr.Slider(1.0, 1.5, value=1.0, step=0.1,
                label="📈 SLA 등급", info="1.0=표준, 1.2=높음, 1.5=미션크리티컬")
            security_level = gr.Slider(1.0, 1.6, value=1.0, step=0.1,
                label="🔐 보안 등급", info="1.0=일반, 1.3=강화, 1.6=최고")
        
        estimate_btn = gr.Button("🚀 견적 산정", variant="primary", size="lg")
        
        gr.Markdown("### 📌 예제 시나리오")
        gr.Examples(
            examples=EXAMPLES,
            inputs=[N_pages, doc_complexity, language_mix, table_ratio,
                   image_quality, model_size, training_epochs, agent_complexity,
                   deployment_type, sla_level, security_level],
        )
    
    with gr.Tab("📊 견적 결과"):
        
        summary_text = gr.Markdown()
        
        gr.Markdown("### 📥 견적서 다운로드")
        with gr.Row():
            pdf_download = gr.File(label="📄 PDF")
            excel_download = gr.File(label="📊 Excel")
        
        with gr.Row():
            phase_chart = gr.Plot()
            cost_chart = gr.Plot()
        
        timeline_chart = gr.Plot()
        
        gr.Markdown("### 💻 하드웨어")
        hw_table = gr.Dataframe()
        
        gr.Markdown("### 🔧 오픈소스")
        oss_table = gr.Dataframe()
    
    with gr.Tab("ℹ️ 파라미터 가이드"):
        
        gr.Markdown("""
        # 📖 파라미터 상세 설명
        
        ## 📊 문서 복잡도
        - **0.7 (단순)**: 텍스트 위주, 표 없음
        - **1.0 (보통)**: 텍스트 + 단순 표
        - **1.3 (복잡)**: 텍스트 + 복잡한 표 + 이미지
        - **1.6 (매우복잡)**: 다단 레이아웃 + 수식 + 다국어
        
        ## 🌐 언어 복잡도
        - **0.8 (단일)**: 한국어만
        - **1.0 (이중)**: 한국어 + 영어
        - **1.3 (다국어)**: 한/영/일/중 혼합
        - **1.5 (특수)**: 다국어 + 특수문자
        
        ## 📋 표 비율
        - 전체 문서 중 표가 포함된 비율 (%)
        - 표 구조 인식은 가장 복잡한 작업
        
        ## 🖼️ 이미지 품질
        - **0.8 (고품질)**: 스캔 300dpi+
        - **1.0 (보통)**: 스캔 200dpi
        - **1.3 (저품질)**: 스캔 150dpi
        - **1.6 (매우낮음)**: 사진촬영, 왜곡
        
        ## 🤖 모델 크기
        - **0.8 (소형)**: 2B~7B 파라미터
        - **1.0 (중형)**: 8B~14B
        - **1.3 (대형)**: 20B~40B
        - **1.6 (초대형)**: 70B+
        
        ## 🎯 Agent 복잡도
        - **0.8 (기본)**: 단일 Agent, 단순 RAG
        - **1.0 (표준)**: 2~3 Agent
        - **1.3 (고급)**: Multi-Agent, 복잡한 Tool
        - **1.6 (엔터프라이즈)**: Self-Learning
        
        ## 🏗️ 배포 환경
        - **0.9 (Cloud)**: AWS/GCP/Azure
        - **1.0 (On-Premise)**: 자체 서버
        - **1.4 (Air-Gap)**: 폐쇄망, 고보안
        
        ## 📈 SLA 등급
        - **1.0 (표준)**: 99% 가용성
        - **1.2 (높음)**: 99.5% 가용성
        - **1.5 (미션크리티컬)**: 99.9% 가용성
        
        ## 🔐 보안 등급
        - **1.0 (일반)**: 기본 인증/암호화
        - **1.3 (강화)**: 다중 인증, 감사 로그
        - **1.6 (최고)**: Zero-Trust, 완전 격리
        
        ---
        
        ## 💰 금액 산출 기준
        
        ### 통화 및 단위
        - **기준**: 원화 (KRW)
        - **표시**: 억원
        - **환율**: USD 1,330원
        
        ### 인건비
        - **1 MM = 15,000,000원** (1,500만원/월)
        
        ### GPU 단가
        - **A100 80GB: 40억원** (≈ $30,000)
        - **H100 80GB: 60억원** (≈ $45,000)
        
        ### 기타
        - **OSS 구축: 300만원/MM**
        - **스토리지: 200만원/TB**
        """)
    
    with gr.Tab("💰 금액 상세"):
        
        gr.Markdown(f"""
        # 💰 금액 산출 상세
        
        ## 인건비 (원화)
        
        | 직급 | 월 단가 | 연봉 환산 |
        |------|---------|----------|
        | 아키텍트 | {LABOR_RATES['Architect']:,}원 | {LABOR_RATES['Architect']*12:,}원 |
        | 시니어 | {LABOR_RATES['Senior_Engineer']:,}원 | {LABOR_RATES['Senior_Engineer']*12:,}원 |
        | 중급 | {LABOR_RATES['Mid_Engineer']:,}원 | {LABOR_RATES['Mid_Engineer']*12:,}원 |
        | 주니어 | {LABOR_RATES['Junior_Engineer']:,}원 | {LABOR_RATES['Junior_Engineer']*12:,}원 |
        | **평균** | **{LABOR_RATES['Average']:,}원** | **{LABOR_RATES['Average']*12:,}원** |
        
        ## GPU 단가 (원화)
        
        | GPU | 단가 (원) | 단가 (달러) | 용도 |
        |-----|-----------|------------|------|
        | H100 80GB | {GPU_COSTS_KRW['H100_80GB']:,}원 | $45,000 | 대규모 학습 |
        | A100 80GB | {GPU_COSTS_KRW['A100_80GB']:,}원 | $30,000 | 표준 학습 |
        | A100 40GB | {GPU_COSTS_KRW['A100_40GB']:,}원 | $18,750 | 개발/테스트 |
        | L40S | {GPU_COSTS_KRW['L40S']:,}원 | $11,250 | 전처리 |
        
        ## 기타 비용
        
        | 항목 | 단가 | 단위 |
        |------|------|------|
        | 스토리지 (NVMe) | {STORAGE_COST_PER_TB:,}원 | TB |
        | OSS 구축 | {OSS_SETUP_COST_PER_MM:,}원 | MM |
        | 고급 서버 | {SERVER_COSTS_KRW['CPU_High_End']:,}원 | 대 |
        | RAM 512GB | {SERVER_COSTS_KRW['RAM_512GB']:,}원 | 세트 |
        
        ## 비용 산정 공식
```
        Total = Labor + GPU + Server + Storage + OSS + Infrastructure
        
        Labor = MM × 15,000,000원
        GPU = GPU_Count × GPU_Unit_Price
        OSS = MM × 3,000,000원
        Infrastructure = (GPU + Server + Storage) × 0.3
```
        
        ## 안전계수
        - **안전계수**: 1.4 (40% 버퍼)
        - **GPU 효율**: 0.65 (65% 활용률)
        - **OSS 인력**: 1.5배 (상용 대비)
        """)
    
    estimate_btn.click(
        fn=run_estimation,
        inputs=[N_pages, doc_complexity, language_mix, table_ratio,
                image_quality, model_size, training_epochs, agent_complexity,
                deployment_type, sla_level, security_level],
        outputs=[summary_text, phase_chart, cost_chart, timeline_chart, 
                hw_table, oss_table, pdf_download, excel_download]
    )

if __name__ == "__main__":
    print("🚀 Starting Gradio app...")
    demo.launch()