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": "ja-jp",
    "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();
        }
    }
};