// MAIThinking1 核心架构
type MAIThinking1 struct {
    Config        ModelConfig
    Embedding     *TokenEmbedding
    MoDBlocks     []*MixtureOfDepthsBlock
    OutputHead    *LMHead
    KVStore       *KeyValueCache  // 推理时KV缓存
}

type ModelConfig struct {
    HiddenDim      int   // 隐藏维度
    NumLayers      int   // 层数
    NumHeads       int   // 注意力头数
    MoDExperts     int   // 深度混合专家数
    TopKExperts    int   // 每层激活专家数
    RouterDim      int   // 路由维度
    VocabSize      int   // 词表大小
    MaxSeqLen      int   // 最大序列长度
}

// MixtureOfDepthsBlock MoD块 — 稀疏深度激活
type MixtureOfDepthsBlock struct {
    // 注意力层（所有Token都经过）
    Attention    *MultiHeadAttention
    AttnNorm     *LayerNorm
    
    // 深度路由（决定哪些Token需要经过FFN）
    DepthRouter  *DepthRouter
    
    // 专家FFN层（MoD仅激活部分Token的FFN）
    ExpertFFNs   []*FeedForward
    SharedFFN    *FeedForward  // 共享专家
    
    // 输出归一化
    OutputNorm   *LayerNorm
}

// DepthRouter 深度路由 — 决定每个Token是否需要FFN计算
type DepthRouter struct {
    Weights      [][]float32  // 路由权重 [hidden_dim, num_experts]
    Bias         []float32    // 偏置
    Capacity     float32      // 容量比例，如0.5表示50%的Token走FFN
}

func (r *DepthRouter) Route(hiddenStates [][]float32) ([]int, []float32) {
    seqLen := len(hiddenStates)
    scores := make([]float32, seqLen)
    
    for i, h := range hiddenStates {
        // 计算每个Token的"深度分数"
        score := 0.0
        for j, w := range r.Weights {
            score += h[j] * w[0]  // 简化为单专家路由
        }
        score += r.Bias[0]
        scores[i] = float32(score)
    }
    
    // 按分数排序，选择Top-K的Token
    type tokenScore struct {
        idx   int
        score float32
    }
    ranked := make([]tokenScore, seqLen)
    for i, s := range scores {
        ranked[i] = tokenScore{idx: i, score: s}
    }
    sort.Slice(ranked, func(i, j int) bool {
        return ranked[i].score > ranked[j].score
    })
    
    k := int(float32(seqLen) * r.Capacity)
    if k < 1 {
        k = 1
    }
    
    selected := make([]int, k)
    selectedScores := make([]float32, k)
    for i := 0; i < k; i++ {
        selected[i] = ranked[i].idx
        selectedScores[i] = ranked[i].score
    }
    
    return selected, selectedScores
}

// MoDBlock前向传播
func (b *MixtureOfDepthsBlock) Forward(x [][]float32) [][]float32 {
    // 1. 注意力（所有Token）
    attnOut := b.Attention.Forward(b.AttnNorm.Forward(x))
    x = add(x, attnOut)  // 残差连接
    
    // 2. 深度路由（选择需要FFN的Token）
    selected, _ := b.DepthRouter.Route(x)
    selectedSet := make(map[int]bool)
    for _, idx := range selected {
        selectedSet[idx] = true
    }
    
    // 3. 仅对选中的Token执行FFN
    ffnOut := make([][]float32, len(x))
    copy(ffnOut, x)  // 未选中的Token保持原值
    
    for _, idx := range selected {
        // 共享专家（所有选中Token都经过）
        shared := b.SharedFFN.Forward(x[idx])
        
        // 稀疏专家路由（每个Token选择Top-2专家）
        expertOut := b.sparseExpertForward(x[idx])
        
        ffnOut[idx] = add(shared, expertOut)
    }
    
    // 4. 残差连接
    output := make([][]float32, len(x))
    for i := range output {
        output[i] = add(x[i], ffnOut[i])
    }
    
    return b.OutputNorm.Forward(output)
}

"""
MAI推理优化策略 — 面向Office场景的推理引擎
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional, Dict, List, Tuple
import time
import math

class MAIInferenceEngine:
    """
    MAI推理引擎 — 针对Office场景定制优化
    """
    def __init__(self, model_path: str, device: str = "cuda"):
        self.model = self._load_model(model_path)
        self.device = device
        self.model.eval()
        
        # 优化配置
        self.config = {
            "max_batch_size": 64,           # 最大批处理
            "kv_cache_size": 2048,          # KV缓存大小
            "speculative_tokens": 5,        # 投机解码步数
            "quantization": "int4",         # 量化级别
            "prompt_length": 256,           # 短提示长度阈值
        }
        
        # 统计信息
        self.stats = {
            "total_requests": 0,
            "cache_hits": 0,
            "avg_latency_ms": 0.0,
            "total_tokens": 0,
        }
        
    def _load_model(self, path: str) -> nn.Module:
        """加载MAI模型"""
        # 实际实现从磁盘加载
        return None
        
    # ========== 策略一：投机解码（Speculative Decoding）==========
    def speculative_generate(
        self, 
        prompt: torch.Tensor,
        max_new_tokens: int = 128,
        gamma: int = 5,  # 投机步数
    ) -> torch.Tensor:
        """
        投机解码：用小模型草稿，大模型验证
        在Office场景中，很多回复（如邮件摘要、Excel公式）是短序列
        投机解码可以大幅降低延迟
        """
        # 小模型（草稿模型）快速生成gamma个候选token
        draft_tokens = self._draft_model_generate(prompt, gamma)
        
        # 大模型一次性验证所有候选token
        with torch.no_grad():
            # 拼接prompt和候选token
            extended = torch.cat([prompt, draft_tokens], dim=-1)
            
            # 大模型前向传播
            logits = self.model(extended)
            
            # 逐位置验证
            accepted = []
            for i in range(gamma):
                # 检查大模型在位置i的分布是否与草稿一致
                draft_logits = logits[:, prompt.shape[-1] + i - 1, :]
                draft_prob = F.softmax(draft_logits, dim=-1)
                
                # 拒绝采样：如果大模型概率低于草稿概率，拒绝
                draft_token = draft_tokens[:, i]
                p_draft = draft_prob.gather(-1, draft_token.unsqueeze(-1)).squeeze(-1)
                
                # 大模型自己在同一位置的概率
                target_logits = logits[:, prompt.shape[-1] + i, :]
                target_prob = F.softmax(target_logits, dim=-1)
                p_target = target_prob.gather(-1, draft_token.unsqueeze(-1)).squeeze(-1)
                
                # 接受条件：p_target / p_draft > uniform(0,1)
                accept_ratio = (p_target / (p_draft + 1e-8)).clamp(max=1.0)
                if torch.rand(1, device=self.device) < accept_ratio:
                    accepted.append(draft_token)
                    self.stats["cache_hits"] += 1
                else:
                    # 拒绝：从大模型分布采样替代token
                    corrected = torch.multinomial(target_prob, 1)
                    accepted.append(corrected.squeeze(-1))
                    break
            
            # 如果全部接受，再用大模型生成一个token
            if len(accepted) == gamma:
                last_logits = self.model(torch.cat([prompt, draft_tokens], dim=-1))
                last_logits = last_logits[:, -1, :]
                next_token = torch.multinomial(F.softmax(last_logits, dim=-1), 1)
                accepted.append(next_token.squeeze(-1))
        
        return torch.stack(accepted)
    
    # ========== 策略二：INT4量化 + KV缓存量化 ==========
    def quantize_kv_cache(self, key: torch.Tensor, value: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        KV缓存INT4量化
        Office场景上下文通常较短（邮件、表格），
        但并发请求多，量化KV缓存可以节省显存带宽
        """
        def quantize_tensor(t: torch.Tensor, bits: int = 4) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
            """逐通道量化"""
            # 计算每通道的min/max
            min_val = t.amin(dim=-1, keepdim=True)
            max_val = t.amax(dim=-1, keepdim=True)
            
            # 量化到 [0, 2^bits - 1]
            scale = (max_val - min_val) / (2**bits - 1)
            scale = scale.clamp(min=1e-10)
            
            q_val = ((t - min_val) / scale).round().to(torch.uint8)
            
            if bits == 4:
                # 打包两个4-bit到1个uint8
                q_val = q_val[:, :, :, ::2] | (q_val[:, :, :, 1::2] << 4)
            
            return q_val, min_val, scale
        
        def dequantize(q_val: torch.Tensor, min_val: torch.Tensor, 
                       scale: torch.Tensor, bits: int = 4) -> torch.Tensor:
            """反量化"""
            if bits == 4:
                # 解包
                low = q_val & 0x0F
                high = (q_val >> 4) & 0x0F
                q_val = torch.stack([low, high], dim=-1).reshape(q_val.shape[:-1] + (-1,))
            
            return q_val.float() * scale + min_val
        
        q_key, k_min, k_scale = quantize_tensor(key)
        q_value, v_min, v_scale = quantize_tensor(value)
        
        return (q_key, k_min, k_scale), (q_value, v_min, v_scale)
    
    # ========== 策略三：连续批处理（Continuous Batching）==========
    def continuous_batch_infer(
        self,
        requests: List[Dict],
        max_batch_tokens: int = 4096,
    ) -> List[torch.Tensor]:
        """
        连续批处理：动态管理批处理队列
        Office场景下，大量并发请求（如50个用户同时问Excel公式）
        传统批处理需要等所有请求完成才能释放资源
        连续批处理允许请求动态加入/退出
        """
        results = [None] * len(requests)
        
        # 初始化KV缓存
        kv_caches = {}
        active_requests = list(range(len(requests)))
        
        while active_requests:
            # 构建当前批次
            batch_prompts = []
            batch_indices = []
            
            total_tokens = 0
            for idx in active_requests:
                req = requests[idx]
                prefix = req.get("prefix", "")
                prompt = req.get("prompt", "")
                
                # 如果有缓存，从缓存继续
                if idx in kv_caches:
                    # 增量生成
                    pass
                else:
                    tokens = self._tokenize(prompt)
                    batch_prompts.append(tokens)
                    batch_indices.append(idx)
                    total_tokens += tokens.shape[-1]
                    
                    # 预分配KV缓存
                    kv_caches[idx] = self._init_kv_cache()
                    
                if total_tokens > max_batch_tokens:
                    break
            
            if not batch_prompts:
                break
            
            # 批次前向传播
            batch_tensor = torch.stack(batch_prompts)
            batch_logits = self.model(batch_tensor)
            
            # 逐请求采样并更新KV缓存
            for i, idx in enumerate(batch_indices):
                next_token = torch.multinomial(
                    F.softmax(batch_logits[i, -1:, :], dim=-1), 1
                )
                
                # 更新KV缓存
                self._update_kv_cache(kv_caches[idx], batch_logits[i])
                
                # 检查是否生成结束
                if self._is_eos(next_token) or \
                   len(requests[idx].get("output", [])) >= requests[idx].get("max_tokens", 128):
                    results[idx] = torch.cat(requests[idx].get("output", []), next_token)
                    active_requests.remove(idx)
                else:
                    requests[idx]["output"] = requests[idx].get("output", []) + [next_token]
        
        return results
    
    # ========== 策略四：PagedAttention显存管理 ==========
    class PagedKVBlock:
        """分页KV缓存块 — 参考vLLM"""
        def __init__(self, block_size: int = 16, num_heads: int = 32, head_dim: int = 128):
            self.block_size = block_size
            self.num_blocks = 0
            self.num_heads = num_heads
            self.head_dim = head_dim
            
            # 逻辑块 -> 物理块映射
            self.block_table: Dict[int, int] = {}
            
            # 物理块存储
            self.key_blocks: List[torch.Tensor] = []
            self.value_blocks: List[torch.Tensor] = []
            
        def allocate_block(self) -> int:
            """分配新物理块"""
            block_idx = self.num_blocks
            self.key_blocks.append(torch.zeros(
                self.block_size, self.num_heads, self.head_dim,
                dtype=torch.float16
            ))
            self.value_blocks.append(torch.zeros(
                self.block_size, self.num_heads, self.head_dim,
                dtype=torch.float16
            ))
            self.num_blocks += 1
            return block_idx
        
        def write(self, logical_block: int, key: torch.Tensor, value: torch.Tensor):
            """写入KV缓存块"""
            if logical_block not in self.block_table:
                self.block_table[logical_block] = self.allocate_block()
            
            physical_block = self.block_table[logical_block]
            seq_len = key.shape[0]
            self.key_blocks[physical_block][:seq_len] = key
            self.value_blocks[physical_block][:seq_len] = value

// OfficeTaskOptimizer Office场景优化器
type OfficeTaskOptimizer struct {
    taskRouter    *TaskRouter      // 任务路由（短/长任务分流）
    promptCache   *PromptCache     // 提示缓存
    resultCache   *ResultCache     // 结果缓存
    prefillOpt    *PrefillOptimizer // 预填充优化
}

// TaskRouter 任务路由 — 根据任务类型选择最优推理路径
type TaskRouter struct {
    shortTaskThreshold int  // 短任务Token阈值
    useSpeculative     bool // 是否使用投机解码
    usePrefixCache     bool // 是否使用前缀缓存
}

func (r *TaskRouter) Route(task *OfficeTask) InferencePath {
    // 1. 判断任务类型
    switch task.TaskType {
    case "excel_formula":
        // Excel公式：短文本，需要精确结果
        return InferencePath{
            Model:       "MAI-Thinking-1",
            Strategy:    "speculative",  // 投机解码加速
            MaxTokens:   64,
            Temperature: 0.1,            // 低温度保证精确性
        }
        
    case "outlook_summary":
        // 邮件摘要：中等长度，需要理解能力
        return InferencePath{
            Model:       "MAI-Thinking-1",
            Strategy:    "standard",
            MaxTokens:   256,
            Temperature: 0.3,
            UseRAG:      true,  // 检索邮件上下文
        }
        
    case "excel_chart_analysis":
        // 图表分析：需要视觉理解
        return InferencePath{
            Model:       "MAI-Vision-1",
            Strategy:    "vision",
            MaxTokens:   512,
            Temperature: 0.2,
        }
        
    case "quick_reply":
        // 快速回复：极短文本，延迟敏感
        return InferencePath{
            Model:       "MAI-Thinking-1-Lite",  // 小模型
            Strategy:    "speculative",
            MaxTokens:   32,
            Temperature: 0.7,
        }
    }
    
    return InferencePath{Model: "MAI-Thinking-1", Strategy: "standard"}
}

// PromptCache 提示缓存 — 缓存重复的prompt计算结果
type PromptCache struct {
    cache     map[string]*CachedPrompt  // prompt hash -> cache
    maxSize   int
    hitRatio  float64
}

type CachedPrompt struct {
    PromptHash string
    KVCache    []byte          // 序列化的KV缓存
    PrefixLen  int             // 缓存的前缀长度
    AccessTime int64           // 最后访问时间
    HitCount   int64           // 命中次数
}

func (c *PromptCache) Lookup(prompt string) (*CachedPrompt, bool) {
    hash := hashPrompt(prompt)
    cached, ok := c.cache[hash]
    if ok {
        cached.HitCount++
        c.hitRatio = float64(c.hitRatio*0.9 + 0.1)  // 指数移动平均
        return cached, true
    }
    return nil, false
}

// ResultCache 结果缓存 — 完全相同的请求直接返回缓存结果
type ResultCache struct {
    cache       map[string]*CachedResult
    ttlSeconds  int64  // 缓存有效期
}

type CachedResult struct {
    Result      string
    CreatedAt   int64
    ExpiresAt   int64
}

func (c *ResultCache) Get(prompt string, context string) (*CachedResult, bool) {
    key := hashPrompt(prompt + "||" + context)
    result, ok := c.cache[key]
    if !ok || time.Now().Unix() > result.ExpiresAt {
        return nil, false
    }
    return result, true
}

def calculate_cost_savings(daily_requests: int, avg_tokens_per_request: int):
    """
    计算MAI替换OpenAI/Anthropic的成本节省
    """
    # OpenAI API成本（GPT-5.6 Terra级别）
    openai_input_cost = 3.0   # $/M input tokens
    openai_output_cost = 15.0 # $/M output tokens
    
    # MAI自研模型推理成本（基于Azure内部定价）
    mai_input_cost = 0.8      # $/M input tokens (含量化+缓存优化)
    mai_output_cost = 3.0     # $/M output tokens
    
    # 假设输出/输入比例为1:3
    daily_input_tokens = daily_requests * avg_tokens_per_request * 3
    daily_output_tokens = daily_requests * avg_tokens_per_request
    
    openai_daily = (daily_input_tokens / 1_000_000 * openai_input_cost +
                    daily_output_tokens / 1_000_000 * openai_output_cost)
    
    mai_daily = (daily_input_tokens / 1_000_000 * mai_input_cost +
                 daily_output_tokens / 1_000_000 * mai_output_cost)
    
    annual_savings = (openai_daily - mai_daily) * 365
    
    return {
        "openai_daily": round(openai_daily, 2),
        "mai_daily": round(mai_daily, 2),
        "daily_savings": round(openai_daily - mai_daily, 2),
        "annual_savings": round(annual_savings, 2),
        "reduction_pct": round((1 - mai_daily / openai_daily) * 100, 1),
    }

# 场景1：中小企业（500用户，每用户每天10次请求）
sme = calculate_cost_savings(5000, 256)
print(f"中小企业 (500用户):")
print(f"  OpenAI每日成本: ${sme['openai_daily']}")
print(f"  MAI每日成本: ${sme['mai_daily']}")
print(f"  每日节省: ${sme['daily_savings']}")
print(f"  年节省: ${sme['annual_savings']}")
print(f"  成本降低: {sme['reduction_pct']}%")

# 场景2：大型企业（50000用户，每用户每天50次请求）
enterprise = calculate_cost_savings(2500000, 256)
print(f"\n大型企业 (50000用户):")
print(f"  OpenAI每日成本: ${enterprise['openai_daily']}")
print(f"  MAI每日成本: ${enterprise['mai_daily']}")
print(f"  每日节省: ${enterprise['daily_savings']}")
print(f"  年节省: ${enterprise['annual_savings']}")
print(f"  成本降低: {enterprise['reduction_pct']}%")