"""
腾讯Hy3登顶分析：免费投放策略的Token经济学
"""
class FreeTierAnalysis:
    def __init__(self):
        self.hy3_weekly_tokens = 6.13e12  # 6.13万亿
        self.hy3_days_to_top = 6  # 6天登顶
        self.hy3_total_params = 295e9  # 2950亿
        self.hy3_active_params = 21e9  # 210亿激活
        self.hy3_context = 256 * 1024  # 256K
        
        self.deepseek_weekly = 5.22e12
        self.deepseek_prior_weeks = 7  # 七连冠
        
    def compute_cost_advantage(self):
        """计算Hy3 vs DeepSeek V4 Pro的性价比"""
        # Hy3定价
        hy3_input_price = 0.14  # $0.14/百万Token
        hy3_output_price = 0.42  # $0.42/百万Token
        
        # DeepSeek V4 Pro定价
        ds_input_price = 0.44  # $0.44/百万Token
        ds_output_price = 1.44  # $1.44/百万Token
        
        # 假设Agent工作流平均输入输出比4:1
        avg_input_ratio = 0.8
        avg_output_ratio = 0.2
        
        hy3_per_million = avg_input_ratio * hy3_input_price + avg_output_ratio * hy3_output_price
        ds_per_million = avg_input_ratio * ds_input_price + avg_output_ratio * ds_output_price
        
        print("=" * 60)
        print("腾讯Hy3 vs DeepSeek V4 Pro 成本对比")
        print("=" * 60)
        print(f"Hy3 综合成本: ${hy3_per_million:.3f}/百万Token")
        print(f"DeepSeek V4 Pro 综合成本: ${ds_per_million:.3f}/百万Token")
        print(f"成本差: {(ds_per_million - hy3_per_million) / ds_per_million * 100:.1f}%")
        
        # 月度账单对比
        monthly_tokens = 500e9  # 5000亿Token/月
        print(f"\n月调用5000亿Token的账单对比:")
        print(f"  Hy3: ${monthly_tokens / 1e6 * hy3_per_million:,.0f}")
        print(f"  DeepSeek V4 Pro: ${monthly_tokens / 1e6 * ds_per_million:,.0f}")
        print(f"  月节省: ${monthly_tokens / 1e6 * (ds_per_million - hy3_per_million):,.0f}")
        
        return hy3_per_million, ds_per_million

    def analyze_hy3_architecture(self):
        """分析Hy3的技术架构优势"""
        print("\n" + "=" * 60)
        print("腾讯Hy3 核心技术参数")
        print("=" * 60)
        
        specs = {
            "总参数": "2950亿",
            "激活参数": "210亿",
            "架构": "MoE (Mixture of Experts)",
            "上下文长度": "256K tokens",
            "SWE-bench Pro": "57.9%",
            "开源协议": "Apache 2.0",
            "发布日股价涨幅": "+4.82%",
            "快慢思考融合": "Hy3 快慢双系统",
        }
        
        for k, v in specs.items():
            print(f"  {k:15s}: {v}")
        
        print(f"\n架构亮点:")
        print(f"  1. 2950亿参数中仅激活210亿 → 推理效率极高")
        print(f"  2. 256K上下文 = 市面主流大模型的4-8倍")
        print(f"  3. SWE-bench Pro 57.9%反超DeepSeek V4 Pro")
        print(f"  4. 限时免费策略 → 快速抢占API流量入口")

analysis = FreeTierAnalysis()
analysis.compute_cost_advantage()
analysis.analyze_hy3_architecture()

"""
全球AI大模型API价格对比分析
"""
import pandas as pd

class APIPriceComparison:
    def __init__(self):
        self.models = {
            "GPT-5.6 Sol (OpenAI)": {"input": 5.00, "output": 30.00, "context": 1050000},
            "GPT-5.6 Terra (OpenAI)": {"input": 2.50, "output": 15.00, "context": 1050000},
            "GPT-5.6 Luna (OpenAI)": {"input": 1.00, "output": 6.00, "context": 1050000},
            "Claude Fable 5 (Anthropic)": {"input": 15.00, "output": 75.00, "context": 200000},
            "Claude Opus 4.8 (Anthropic)": {"input": 15.00, "output": 75.00, "context": 200000},
            "Grok 4.5 (SpaceXAI)": {"input": 2.00, "output": 6.00, "context": 500000},
            "Muse Spark 1.1 (Meta)": {"input": 1.25, "output": 4.25, "context": 1000000},
            "腾讯Hy3 (free)": {"input": 0.14, "output": 0.42, "context": 256000},
            "DeepSeek V4 Flash": {"input": 0.09, "output": 0.18, "context": 128000},
            "小米MiMo-V2.5": {"input": 0.18, "output": 0.54, "context": 128000},
            "智谱GLM 5.2": {"input": 0.15, "output": 0.50, "context": 128000},
            "MiniMax M3": {"input": 0.20, "output": 0.60, "context": 128000},
        }
    
    def analyze(self):
        print("=" * 110)
        print(f"{'模型':30s} {'输入$/M':10s} {'输出$/M':10s} {'上下文':10s} {'综合成本':12s} {'vs Fable 5':12s}")
        print("=" * 110)
        
        # 基准：Fable 5
        fable5_input = 15.00
        fable5_output = 75.00
        
        for name, spec in sorted(self.models.items(), key=lambda x: x[1]["input"]):
            input_p = spec["input"]
            output_p = spec["output"]
            # 综合成本（假设4:1输入输出比）
            blended = 0.8 * input_p + 0.2 * output_p
            fable5_blended = 0.8 * fable5_input + 0.2 * fable5_output
            
            ratio = fable5_blended / blended if blended > 0 else float('inf')
            context_k = spec["context"] // 1000
            
            print(f"{name:30s} ${input_p:<5.2f}  ${output_p:<5.2f}  {context_k:>5d}K  "
                  f"${blended:<6.2f}  {'免费' if ratio == float('inf') else f'x{ratio:.1f}':>10s}")
        
        print("\n" + "=" * 110)
        print("关键发现：")
        print("  1. 中国模型API价格普遍为美国闭源模型的1/20 - 1/100")
        print("  2. DeepSeek V4 Flash输出价格($0.18)仅为GPT-5.5($30)的1/166")
        print("  3. 腾讯Hy3免费策略直接打穿定价体系")
        print("  4. 英伟达Nemotron 3 Ultra成本仅为头部闭源模型1/10")
        print("  5. 成本效率已成为开发者模型选型的首要决策因素")

APIPriceComparison().analyze()

package main

import (
	"fmt"
	"math"
	"sort"
)

// 模型定价信息
type ModelPricing struct {
	Name        string
	InputPrice  float64 // $/百万Token
	OutputPrice float64 // $/百万Token
	ContextLen  int     // 上下文长度
	IsChinese   bool
	MonthlyVol  float64 // 月调用量（万亿Token）
}

// 企业级Token消耗场景
type UsageScenario struct {
	Name           string
	DailyUsers     int
	AvgInputTokens int    // 每次请求平均输入Token
	AvgOutputTokens int   // 每次请求平均输出Token
	RequestsPerDay int    // 每用户每日请求数
	Description    string
}

// Token经济分析器
type TokenEconomyAnalyzer struct {
	models   []ModelPricing
	scenarios []UsageScenario
}

func NewTokenEconomyAnalyzer() *TokenEconomyAnalyzer {
	return &TokenEconomyAnalyzer{
		models: []ModelPricing{
			{"GPT-5.6 Sol", 5.00, 30.00, 1050000, false, 0},
			{"GPT-5.6 Terra", 2.50, 15.00, 1050000, false, 0},
			{"Claude Fable 5", 15.00, 75.00, 200000, false, 0},
			{"Grok 4.5", 2.00, 6.00, 500000, false, 0},
			{"Muse Spark 1.1", 1.25, 4.25, 1000000, false, 0},
			{"腾讯Hy3 (free)", 0.14, 0.42, 256000, true, 6.13},
			{"DeepSeek V4 Flash", 0.09, 0.18, 128000, true, 5.22},
			{"小米MiMo-V2.5", 0.18, 0.54, 128000, true, 5.95},
			{"智谱GLM 5.2", 0.15, 0.50, 128000, true, 3.19},
			{"MiniMax M3", 0.20, 0.60, 128000, true, 4.26},
			{"英伟达Nemotron 3 Ultra", 0.30, 1.00, 128000, false, 2.04},
		},
		scenarios: []UsageScenario{
			{10000, 2000, 500, 50, "Agentic Coding（中等规模开发团队）"},
			{100000, 3000, 800, 20, "Customer Support Chatbot（企业客服）"},
			{500000, 4000, 1000, 10, "Content Generation（内容生成平台）"},
			{10000, 8000, 2000, 100, "Data Analysis Pipeline（数据分析管线）"},
			{5000, 16000, 4000, 200, "Agentic Workflow（智能体工作流）"},
		},
	}
}

// 计算月度成本
func (m *ModelPricing) MonthlyCost(scenario UsageScenario) float64 {
	// 日均Token = 用户数 × 请求数 × (输入Token + 输出Token)
	dailyInputTokens := float64(scenario.DailyUsers) * float64(scenario.RequestsPerDay) * float64(scenario.AvgInputTokens)
	dailyOutputTokens := float64(scenario.DailyUsers) * float64(scenario.RequestsPerDay) * float64(scenario.AvgOutputTokens)
	
	monthlyInputTokens := dailyInputTokens * 30
	monthlyOutputTokens := dailyOutputTokens * 30
	
	// 成本 = (输入Token/1M × 输入价格) + (输出Token/1M × 输出价格)
	inputCost := monthlyInputTokens / 1e6 * m.InputPrice
	outputCost := monthlyOutputTokens / 1e6 * m.OutputPrice
	
	return inputCost + outputCost
}

// 成本效率评分
func (m *ModelPricing) CostEfficiencyScore(scenario UsageScenario) float64 {
	// 越低越好
	return m.MonthlyCost(scenario)
}

func (a *TokenEconomyAnalyzer) RunAllScenarios() {
	fmt.Println("=" * 120)
	fmt.Println("Token Economy Scenario Analysis: 企业月度AI成本对比")
	fmt.Println("=" * 120)
	
	for _, scenario := range a.scenarios {
		fmt.Printf("\n--- Scenario: %s ---\n", scenario.Description)
		fmt.Printf("  用户数: %d, 每用户日请求: %d, 输入/输出: %d/%d Token\n",
			scenario.DailyUsers, scenario.RequestsPerDay,
			scenario.AvgInputTokens, scenario.AvgOutputTokens)
		fmt.Println("-" * 80)
		fmt.Printf("%-30s %15s %15s %15s\n", "Model", "Monthly Cost", "Per User Cost", "Efficiency")
		fmt.Println("-" * 80)
		
		type result struct {
			name     string
			cost     float64
			perUser  float64
		}
		
		var results []result
		for _, model := range a.models {
			cost := model.MonthlyCost(scenario)
			perUser := cost / float64(scenario.DailyUsers)
			results = append(results, result{model.Name, cost, perUser})
		}
		
		sort.Slice(results, func(i, j int) bool {
			return results[i].cost < results[j].cost
		})
		
		for i, r := range results {
			if i >= 5 {
				break
			}
			fmt.Printf("%-30s $%13.0f $%13.2f/mo\n", r.name, r.cost, r.perUser)
		}
	}
}

// 年度Token经济预测
func (a *TokenEconomyAnalyzer) ProjectAnnualGrowth() {
	fmt.Println("\n" + "=" * 80)
	fmt.Println("全球AI Token经济年度预测 (2026-2028)")
	fmt.Println("=" * 80)
	
	// 基准数据
	baseWeekly := 54.6e12 // 54.6万亿Token/周
	weeklyGrowth := 0.126 // 12.6%周增长
	chinaShare := 0.505  // 50.5%中国占比
	
	fmt.Printf("%-8s %18s %18s %18s\n", "Year", "Weekly Token", "Annual Token", "China Share")
	fmt.Println("-" * 62)
	
	for year := 2026; year <= 2028; year++ {
		weeksSinceBaseline := (year - 2026) * 52
		projectedWeekly := baseWeekly * math.Pow(1+weeklyGrowth, float64(weeksSinceBaseline))
		annualToken := projectedWeekly * 52
		
		// 中国份额增长假设
		chinaShareProjected := chinaShare * math.Pow(1.15, float64(year-2026))
		if chinaShareProjected > 0.7 {
			chinaShareProjected = 0.7
		}
		
		fmt.Printf("  %d    %15.2f万亿   %15.2f万亿   %15.1f%%\n",
			year, projectedWeekly/1e12, annualToken/1e12, chinaShareProjected*100)
	}
	
	fmt.Println("\n\n预测假设：")
	fmt.Println("  1. 周增长12.6%持续（2026上半年实际增速）")
	fmt.Println("  2. 2027年后增速放缓至8%/周")
	fmt.Println("  3. 中国模型份额每年增长15%")
	fmt.Println("  4. Agent工作流驱动Token消耗指数级增长")
}

func main() {
	analyzer := NewTokenEconomyAnalyzer()
	analyzer.RunAllScenarios()
	analyzer.ProjectAnnualGrowth()
	
	// 额外分析：美国企业使用中国模型趋势
	fmt.Println("\n" + "=" * 80)
	fmt.Println("美国企业使用中国模型Token占比趋势")
	fmt.Println("=" * 80)
	fmt.Printf("\n  %-15s %s\n", "时间", "占比")
	fmt.Println("  " + "-" * 40)
	
	shares := []struct {
		period string
		share  float64
	}{
		{"2025 H1", 4.5},
		{"2026-02", 30.0},
		{"2026-03", 35.0},
		{"2026-04", 40.0},
		{"2026-05", 42.0},
		{"2026-06", 46.0},
		{"2026-07 (当前)", 38.0},
	}
	
	for _, s := range shares {
		bar := ""
		for i := 0; i < int(s.share)/2; i++ {
			bar += "█"
		}
		fmt.Printf("  %-15s %5.1f%% %s\n", s.period, s.share, bar)
	}
	
	fmt.Println("\n\n结论：")
	fmt.Println("  1. 美国企业使用中国模型的比例从4.5%飙升至~38%")
	fmt.Println("  2. 核心驱动力：性能接近 + 价格差20-100倍")
	fmt.Println("  3. 中国模型已穿透美国企业付费栈")
	fmt.Println("  4. 2026下半年有望突破50%")
}