import requests
from typing import Dict, List
import json

class OptimizedAIClient:
    def __init__(self):
        self.models = {
            "fast": "qwen-turbo",  # $0.18/$0.18 per 1M tokens
            "balanced": "deepseek-v4-pro",  # $0.27/$0.54 per 1M tokens  
            "premium": "gpt-4o"  # $2.50/$10.00 per 1M tokens
        }
        self.cost_tracker = {
            "fast": 0,
            "balanced": 0,
            "premium": 0
        }

    def route_request(self, complexity_score: int, context_size: int, messages: List[Dict]) -> Dict:
        """
        Route requests based on complexity and cost analysis
        Complexity: 1-10 (1=simple, 10=complex)
        """

        # Decision tree for model routing
        if complexity_score <= 3 and context_size < 10_000:
            return self._call_model("fast", messages)
        elif complexity_score <= 7 and context_size < 50_000:
            return self._call_model("balanced", messages)
        else:
            return self._call_model("premium", messages)

    def _call_model(self, model_type: str, messages: List[Dict]) -> Dict:
        """Call appropriate model and track costs"""
        try:
            response = requests.post(
                "https://api.aiwave.live/v1/chat/completions",
                headers={
                    "Authorization": "Bearer YOUR_API_KEY",
                    "Content-Type": "application/json"
                },
                json={
                    "model": self.models[model_type],
                    "messages": messages,
                    "max_tokens": min(2000, len(messages) * 200)
                }
            )

            # Track cost (simplified calculation)
            input_tokens = sum(len(msg["content"]) for msg in messages) // 4  # rough estimate
            output_tokens = len(response.json()["choices"][0]["message"]["content"]) // 4

            # Update cost tracker
            if model_type == "fast":
                self.cost_tracker["fast"] += (input_tokens * 0.18 + output_tokens * 0.18) / 1_000_000
            elif model_type == "balanced":
                self.cost_tracker["balanced"] += (input_tokens * 0.27 + output_tokens * 0.54) / 1_000_000
            else:
                self.cost_tracker["premium"] += (input_tokens * 2.50 + output_tokens * 10.00) / 1_000_000

            return response.json()

        except Exception as e:
            raise Exception(f"Model {model_type} failed: {e}")

# Usage example
client = OptimizedAIClient()

# Simple Q&A - uses cheapest model
simple_query = [
    {"role": "user", "content": "What is the capital of France?"}
]
result = client.route_request(complexity_score=1, context_size=50, messages=simple_query)

# Complex reasoning - uses balanced model
complex_query = [
    {"role": "user", "content": "Analyze the market trends for AI in 2026 and provide investment recommendations."}
]
result = client.route_request(complexity_score=8, context_size=2000, messages=complex_query)

# Print cost savings
print(f"Cost breakdown: {client.cost_tracker}")
print(f"Total cost: ${sum(client.cost_tracker.values()):.6f}")

class ContextOptimizer:
    @staticmethod
    def compress_context(messages: List[Dict], max_context: int = 50_000) -> List[Dict]:
        """Compress conversation history while preserving essential information"""
        compressed = []
        current_tokens = 0

        for msg in messages:
            msg_tokens = len(msg["content"]) // 4

            if current_tokens + msg_tokens > max_context:
                # Add system reminder about context compression
                compressed.append({
                    "role": "system",
                    "content": "Previous conversation was compressed to fit context limits."
                })
                break

            compressed.append(msg)
            current_tokens += msg_tokens

        return compressed

    @staticmethod
    def summarize_conversation(messages: List[Dict]) -> str:
        """AI-powered conversation summarization"""
        summary_request = {
            "model": "deepseek-v4-pro",
            "messages": [
                {"role": "system", "content": "Summarize this conversation concisely, preserving key points and decisions."},
                {"role": "user", "content": f"Summarize: {' '.join([msg['content'] for msg in messages])}"}
            ],
            "max_tokens": 500
        }

        response = requests.post(
            "https://api.aiwave.live/v1/chat/completions",
            headers={"Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json"},
            json=summary_request
        )

        return response.json()["choices"][0]["message"]["content"]

# Implementation for context management
def create_context_window(messages: List[Dict], max_window: int = 100_000) -> List[Dict]:
    """Create optimized context window using compression and summarization"""

    # First pass: try without compression
    current_tokens = sum(len(msg["content"]) // 4 for msg in messages)

    if current_tokens <= max_window:
        return messages

    # Second pass: compress older messages
    compressed = ContextOptimizer.compress_context(messages, max_window // 2)

    if len(compressed) < len(messages):
        # Add summary of excluded messages
        excluded_messages = messages[len(compressed):]
        summary = ContextOptimizer.summarize_conversation(excluded_messages)

        compressed.append({
            "role": "system",
            "content": f"Previous conversation summary: {summary}"
        })

    return compressed

import hashlib
import json
from datetime import datetime, timedelta

class AIBatchProcessor:
    def __init__(self, cache_ttl_hours: int = 24):
        self.cache = {}
        self.cache_ttl = timedelta(hours=cache_ttl_hours)

    def get_cache_key(self, messages: List[Dict], model: str) -> str:
        """Generate cache key for request"""
        content_hash = hashlib.md5(
            json.dumps(messages, sort_keys=True).encode()
        ).hexdigest()
        return f"{model}_{content_hash}"

    def get_from_cache(self, cache_key: str) -> Dict:
        """Retrieve from cache if valid"""
        if cache_key in self.cache:
            cached_data, timestamp = self.cache[cache_key]
            if datetime.now() - timestamp < self.cache_ttl:
                return cached_data
            else:
                del self.cache[cache_key]
        return None

    def batch_process(self, requests: List[Dict]) -> List[Dict]:
        """Process multiple requests efficiently"""
        results = []
        uncached_requests = []

        # Check cache first
        for request in requests:
            cache_key = self.get_cache_key(request["messages"], request["model"])
            cached_result = self.get_from_cache(cache_key)

            if cached_result:
                results.append(cached_result)
            else:
                uncached_requests.append(request)

        # Process uncached requests in batch
        if uncached_requests:
            batch_results = self._call_batch_api(uncached_requests)

            # Update cache and results
            for i, result in enumerate(batch_results):
                cache_key = self.get_cache_key(
                    uncached_requests[i]["messages"], 
                    uncached_requests[i]["model"]
                )
                self.cache[cache_key] = (result, datetime.now())
                results.append(result)

        return results

    def _call_batch_api(self, requests: List[Dict]) -> List[Dict]:
        """Call batch API efficiently"""
        # Group by model for optimal batching
        model_groups = {}
        for request in requests:
            model = request["model"]
            if model not in model_groups:
                model_groups[model] = []
            model_groups[model].append(request)

        results = []

        # Process each model group
        for model, model_requests in model_groups.items():
            try:
                # Create batch request
                batch_data = {
                    "model": model,
                    "messages": [req["messages"] for req in model_requests],
                    "max_tokens": 1000
                }

                response = requests.post(
                    "https://api.aiwave.live/v1/chat/completions",
                    headers={
                        "Authorization": "Bearer YOUR_API_KEY",
                        "Content-Type": "application/json"
                    },
                    json=batch_data
                )

                # Parse batch results
                batch_results = response.json()
                for i, choice in enumerate(batch_results["choices"]):
                    results.append({
                        "content": choice["message"]["content"],
                        "model": model,
                        "cached": False
                    })

            except Exception as e:
                # Fallback to individual requests if batch fails
                for request in model_requests:
                    try:
                        individual_response = requests.post(
                            "https://api.aiwave.live/v1/chat/completions",
                            headers={
                                "Authorization": "Bearer YOUR_API_KEY",
                                "Content-Type": "application/json"
                            },
                            json={
                                "model": model,
                                "messages": request["messages"],
                                "max_tokens": 1000
                            }
                        )

                        result = individual_response.json()["choices"][0]["message"]
                        results.append({
                            "content": result["content"],
                            "model": model,
                            "cached": False
                        })

                    except Exception:
                        results.append({
                            "content": "Error processing request",
                            "model": model,
                            "cached": False
                        })

        return results

class SmartModelSelector:
    def __init__(self):
        self.model_capabilities = {
            "qwen-turbo": {
                "cost": {"input": 0.18, "output": 0.18},
                "strengths": ["general_qa", "code_generation", "translation"],
                "weaknesses": ["complex_reasoning", "math"],
                "context_limit": 128_000
            },
            "deepseek-v4-pro": {
                "cost": {"input": 0.27, "output": 0.54},
                "strengths": ["complex_reasoning", "technical_analysis", "math"],
                "weaknesses": ["creative_writing"],
                "context_limit": 1_000_000
            },
            "kimi-k2.6": {
                "cost": {"input": 0.55, "output": 0.55},
                "strengths": ["long_context", "document_analysis", "research"],
                "weaknesses": ["code_generation"],
                "context_limit": 200_000
            },
            "gpt-4o": {
                "cost": {"input": 2.50, "output": 10.00},
                "strengths": ["multimodal", "complex_reasoning", "creative"],
                "weaknesses": [],
                "context_limit": 128_000
            }
        }

    def select_best_model(self, task_type: str, content: str, budget: float = None) -> str:
        """Select optimal model based on task and budget"""

        # Get task-specific scoring
        task_scores = {}
        for model, info in self.model_capabilities.items():
            score = 0

            # Base score for task type match
            if task_type in info["strengths"]:
                score += 10
            elif task_type in info["weaknesses"]:
                score -= 5

            # Context size bonus
            context_score = min(len(content) // 4, info["context_limit"]) / info["context_limit"]
            score += context_score * 5

            # Cost penalty (lower is better)
            cost_estimate = (len(content) // 4) * (info["cost"]["input"] + info["cost"]["output"]) / 1_000_000
            score -= cost_estimate * 100

            # Budget constraint
            if budget and cost_estimate > budget:
                score -= 20  # Heavy penalty for over budget

            task_scores[model] = score

        # Select best model
        best_model = max(task_scores, key=task_scores.get)
        return best_model

    def fallback_chain(self, primary_model: str, content: str) -> List[str]:
        """Define fallback chain for reliability"""
        fallback_chains = {
            "qwen-turbo": ["deepseek-v4-pro", "kimi-k2.6", "gpt-4o"],
            "deepseek-v4-pro": ["qwen-turbo", "kimi-k2.6", "gpt-4o"],
            "kimi-k2.6": ["deepseek-v4-pro", "qwen-turbo", "gpt-4o"],
            "gpt-4o": ["deepseek-v4-pro", "kimi-k2.6", "qwen-turbo"]
        }

        return fallback_chains.get(primary_model, [])

# Implementation
selector = SmartModelSelector()

# Task analysis and model selection
task_types = ["general_qa", "code_generation", "complex_reasoning", "translation"]
for task_type in task_types:
    sample_content = "Sample content for " + task_type + " task"
    selected_model = selector.select_best_model(task_type, sample_content)
    print(f"{task_type}: {selected_model}")

    # Get fallback chain
    fallback_chain = selector.fallback_chain(selected_model, sample_content)
    print(f"  Fallback chain: {' → '.join(fallback_chain)}")

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime, timedelta

class CostDashboard:
    def __init__(self):
        self.cost_data = []
        self.usage_data = []

    def record_usage(self, model: str, input_tokens: int, output_tokens: int, success: bool):
        """Record API usage and costs"""
        cost = self.calculate_cost(model, input_tokens, output_tokens)

        self.cost_data.append({
            "timestamp": datetime.now(),
            "model": model,
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "cost": cost,
            "success": success
        })

        self.usage_data.append({
            "timestamp": datetime.now(),
            "model": model,
            "tokens": input_tokens + output_tokens,
            "success": success
        })

    def calculate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
        """Calculate cost for given model and tokens"""
        pricing = {
            "qwen-turbo": (0.18, 0.18),
            "deepseek-v4-pro": (0.27, 0.54),
            "kimi-k2.6": (0.55, 0.55),
            "gpt-4o": (2.50, 10.00)
        }

        if model in pricing:
            input_cost, output_cost = pricing[model]
            return (input_tokens * input_cost + output_tokens * output_cost) / 1_000_000
        return 0

    def generate_report(self, days: int = 30) -> Dict:
        """Generate cost optimization report"""
        cutoff_date = datetime.now() - timedelta(days=days)

        recent_costs = [d for d in self.cost_data if d["timestamp"] > cutoff_date]

        # Calculate metrics
        total_cost = sum(d["cost"] for d in recent_costs)
        total_tokens = sum(d["input_tokens"] + d["output_tokens"] for d in recent_costs)
        success_rate = sum(d["success"] for d in recent_costs) / len(recent_costs) if recent_costs else 0

        # Model breakdown
        model_breakdown = {}
        for model in set(d["model"] for d in recent_costs):
            model_costs = [d for d in recent_costs if d["model"] == model]
            model_breakdown[model] = {
                "cost": sum(d["cost"] for d in model_costs),
                "tokens": sum(d["input_tokens"] + d["output_tokens"] for d in model_costs),
                "requests": len(model_costs)
            }

        # Optimization recommendations
        recommendations = []

        # High-cost model alert
        expensive_models = [m for m, data in model_breakdown.items() 
                           if data["cost"] / total_cost > 0.3 and m != "gpt-4o"]
        if expensive_models:
            recommendations.append(f"Consider replacing {', '.join(expensive_models)} with cheaper alternatives")

        # Low success rate alert
        if success_rate < 0.95:
            recommendations.append(f"Success rate is {success_rate:.2%}. Consider improving error handling")

        # Cost per token analysis
        if total_tokens > 0:
            cost_per_token = total_cost / total_tokens * 1_000_000  # per 1M tokens
            if cost_per_token > 1.0:
                recommendations.append(f"High cost per token (${cost_per_token:.2f}/1M). Consider model optimization")

        return {
            "period_days": days,
            "total_cost": total_cost,
            "total_tokens": total_tokens,
            "success_rate": success_rate,
            "cost_per_token": total_cost / total_tokens * 1_000_000 if total_tokens > 0 else 0,
            "model_breakdown": model_breakdown,
            "recommendations": recommendations,
            "daily_average": total_cost / days
        }

# Dashboard implementation
dashboard = CostDashboard()

# Simulate usage
models = ["qwen-turbo", "deepseek-v4-pro", "kimi-k2.6"]
for _ in range(100):
    model = models[_ % len(models)]
    input_tokens = 1000 + (_ % 5000)
    output_tokens = 100 + (_ % 1000)
    success = _ % 10 != 0  # 90% success rate

    dashboard.record_usage(model, input_tokens, output_tokens, success)

# Generate report
report = dashboard.generate_report(30)
print(f"Total cost: ${report['total_cost']:.2f}")
print(f"Daily average: ${report['daily_average']:.2f}")
print(f"Success rate: {report['success_rate']:.2%}")
print("\nRecommendations:")
for rec in report["recommendations"]:
    print(f"- {rec}")