class IntelligentRouter {
private:
    float complexityThreshold = 0.7;
    
public:
    ProcessingMethod routeRequest(const VoiceCommand& cmd) {
        float complexity = analyzeComplexity(cmd);
        
        if (complexity < complexityThreshold) {
            return ProcessingMethod::LOCAL_EDGE;
        } else {
            return ProcessingMethod::DEEPSEEK_CLOUD;
        }
    }
    
    float analyzeComplexity(const VoiceCommand& cmd) {
        // 复杂度评估算法
        return cmd.hasMultipleEntities() * 0.3 +
               cmd.requiresReasoning() * 0.4 +
               cmd.needsContextHistory() * 0.3;
    }
};

class DeepSeekIntegration {
private:
    static constexpr char* API_ENDPOINT = "https://api.deepseek.com/v1/chat/completions";
    static constexpr int MAX_RETRIES = 3;
    static constexpr int TIMEOUT_MS = 3000;
    
public:
    std::string processWithDeepSeek(const std::string& userInput) {
        json request = {
            {"model", "deepseek-chat"},
            {"messages", {
                {{"role", "system"}, {"content", getSystemPrompt()}},
                {{"role", "user"}, {"content", userInput}}
            }},
            {"max_tokens", 500},
            {"temperature", 0.7}
        };
        
        return sendAPIRequest(request);
    }
    
private:
    std::string getSystemPrompt() {
        return "你是XiaoZhi AI助手，专门为智能家居设备提供控制和信息服务。"
               "请用简洁、友好的语言回复，并在需要时提供设备控制指令。";
    }
};

# 下载XiaoZhi AI预编译固件
wget https://github.com/xiaozhidev/xiaozhi-firmware/releases/latest/xiaozhi-ai-deepseek.bin

# 烧录到ESP32-S3
esptool.py --chip esp32s3 --port /dev/ttyUSB0 --baud 921600 \
  write_flash -z 0x0 xiaozhi-ai-deepseek.bin

{
  "wifi": {
    "ssid": "YourWiFiName",
    "password": "YourPassword"
  },
  "deepseek": {
    "api_key": "sk-xxxxxxxxxxxxxxxxxxxxx",
    "model": "deepseek-chat",
    "max_tokens": 500,
    "temperature": 0.7
  },
  "voice": {
    "wake_word": "你好小智",
    "language": "zh-cn",
    "tts_voice": "female_warm"
  }
}

# 语音唤醒测试
说出: "你好小智"
预期: LED亮起，响应提示音

# 简单指令测试（本地处理）
用户: "打开客厅灯"
系统: [本地识别] → [MQTT控制] → "好的，已为您打开客厅灯"

# 复杂对话测试（DeepSeek处理）
用户: "今天天气适合晾衣服吗？"
系统: [DeepSeek分析] → "今天天气晴朗，湿度较低，非常适合晾衣服哦"

struct CommandComplexity {
    float entityCount;      // 实体数量权重 (0.0-1.0)
    float syntaxComplexity; // 语法复杂度权重 (0.0-1.0)  
    float contextDependency; // 上下文依赖权重 (0.0-1.0)
    float domainSpecific;   // 领域特定权重 (0.0-1.0)
    
    float getOverallComplexity() const {
        return (entityCount * 0.25 + 
                syntaxComplexity * 0.35 + 
                contextDependency * 0.25 + 
                domainSpecific * 0.15);
    }
};

class EdgeIntelligenceEngine {
public:
    ProcessingDecision analyze(const VoiceCommand& cmd) {
        CommandComplexity complexity = evaluateComplexity(cmd);
        
        if (complexity.getOverallComplexity() < 0.4) {
            return {ProcessingMethod::LOCAL, "简单设备控制指令"};
        } else if (complexity.getOverallComplexity() < 0.7) {
            return {ProcessingMethod::HYBRID, "需要轻量云端辅助"};
        } else {
            return {ProcessingMethod::DEEPSEEK_FULL, "复杂推理需DeepSeek处理"};
        }
    }
};

class LocalKnowledgeCache {
private:
    LRUCache<std::string, AIResponse> responseCache;
    BloomFilter knownPatterns;
    
public:
    bool tryLocalResponse(const std::string& input, AIResponse& response) {
        // 1. 精确匹配缓存
        if (responseCache.contains(input)) {
            response = responseCache.get(input);
            return true;
        }
        
        // 2. 模式匹配
        if (knownPatterns.contains(extractPattern(input))) {
            response = generateTemplateResponse(input);
            return true;
        }
        
        return false; // 需要云端处理
    }
    
    void updateCache(const std::string& input, const AIResponse& response) {
        responseCache.put(input, response);
        knownPatterns.add(extractPattern(input));
    }
};

class PromptOptimizer {
private:
    std::string deviceContext;
    std::vector<std::string> recentHistory;
    
public:
    std::string generateContextualPrompt(const std::string& userInput) {
        std::string systemPrompt = R"(
你是XiaoZhi AI助手，当前控制的设备包括: )" + deviceContext + R"(

用户最近的交互历史:
)";
        
        for (const auto& history : recentHistory) {
            systemPrompt += "- " + history + "\n";
        }
        
        systemPrompt += R"(
请基于上下文提供有用、准确的回复，必要时生成设备控制指令。
回复格式: {response: "回复内容", commands: ["指令1", "指令2"]}
)";
        
        return systemPrompt;
    }
};

class PerformanceMonitor {
private:
    struct Metrics {
        uint32_t responseTime;
        float cpuUsage;
        uint32_t memoryUsage;
        bool networkStatus;
    };
    
    CircularBuffer<Metrics, 100> metricsHistory;
    
public:
    void logInteraction(const Metrics& metrics) {
        metricsHistory.push(metrics);
        
        if (metrics.responseTime > 5000) { // 5秒超时
            optimizePerformance();
        }
    }
    
private:
    void optimizePerformance() {
        // 动态调整本地/云端处理策略
        if (getAverageResponseTime() > 3000) {
            increaseLocalProcessingRatio();
        }
    }
};