from agentcode import route_task, get_model_info, ModelType

# Route a task to the best model
model = route_task("Create FastAPI endpoint")
print(model)  # ModelType.DEEPSEEK

# Get model information
info = get_model_info(ModelType.MIMO)
print(info["name"])  # "MiMo-V2.5"

from detector import detect_system_models, print_detection_report

# Detect all available models
models = detect_system_models()

# Print detection report
print_detection_report(models)

from wizard import run_setup_wizard

# Run interactive setup
preferences = run_setup_wizard()

from sessions import get_session_manager, get_model_switcher

# Create a new session
manager = get_session_manager()
session = manager.create_session("mimo", "Create REST API", "python")

# Switch models during session
switcher = get_model_switcher()
switcher.switch_model("deepseek")

# Get session statistics
stats = manager.get_session_stats()
print(stats)

from languages import detect_project_language, get_language_template, ProgrammingLanguage

# Detect project language
language = detect_project_language()
print(language)  # ProgrammingLanguage.PYTHON

# Generate code template
template = get_language_template(
    ProgrammingLanguage.PYTHON,
    "function",
    name="calculate_sum",
    params="a, b",
    docstring="Calculate sum of two numbers"
)
print(template)

model = route_task("Create docker compose file")
# Returns: ModelType.LAGUNA

info = get_model_info(ModelType.DEEPSEEK)
# Returns: {"name": "DeepSeek V4 Flash", "provider": "DeepSeek", "strength": "Speed"}

from enum import Enum
from typing import Dict, List, Optional


class ModelType(str, Enum):
    """Available AI model types."""
    MIMO = "opencode/mimo-v2.5-free"
    DEEPSEEK = "opencode/deepseek-v4-flash-free"
    LAGUNA = "opencode/laguna-s-2.1-free"
    LING = "opencode/ling-3.0-flash-free"
    NORTH = "opencode/north-mini-code-free"
    NEMOTRON = "opencode/nemotron-3-ultra-free"


TERMINAL_KEYWORDS: List[str] = ["bash", "shell", "docker", "terminal", "cli", "script", "deploy"]
SPEED_KEYWORDS: List[str] = ["quick", "fast", "rapid", "batch"]


def route_task(
    task_description: str,
    has_image: bool = False,
    context_size: int = 0,
    is_local_only: bool = False
) -> ModelType:
    """Route a task to the optimal AI model."""
    if not task_description:
        raise ValueError("task_description cannot be empty")
    
    if has_image:
        return ModelType.MIMO
    if any(kw in task_description.lower() for kw in TERMINAL_KEYWORDS):
        return ModelType.LAGUNA
    if context_size > 256000:
        return ModelType.NEMOTRON
    if is_local_only:
        return ModelType.NORTH
    if any(kw in task_description.lower() for kw in SPEED_KEYWORDS):
        return ModelType.DEEPSEEK
    return ModelType.LING


def get_model_info(model: ModelType) -> Dict[str, str]:
    """Get information about a model."""
    models: Dict[ModelType, Dict[str, str]] = {
        ModelType.MIMO: {"name": "MiMo-V2.5", "provider": "Xiaomi", "strength": "Multimodal"},
        ModelType.DEEPSEEK: {"name": "DeepSeek V4 Flash", "provider": "DeepSeek", "strength": "Speed"},
        ModelType.LAGUNA: {"name": "Laguna S 2.1", "provider": "NVIDIA", "strength": "Terminal"},
        ModelType.LING: {"name": "Ling-3.0-flash", "provider": "Alibaba", "strength": "Efficiency"},
        ModelType.NORTH: {"name": "North Mini Code", "provider": "NVIDIA", "strength": "Local"},
        ModelType.NEMOTRON: {"name": "Nemotron 3 Ultra", "provider": "NVIDIA", "strength": "Enterprise"},
    }
    return models.get(model, {})

from agentcode import route_task, get_model_info, ModelType
import pytest


def test_multimodal_routing():
    """Test multimodal task routing."""
    assert route_task("Fix bug", has_image=True) == ModelType.MIMO
    assert route_task("Transcribe audio", has_image=True) == ModelType.MIMO


def test_terminal_routing():
    """Test terminal/CLI task routing."""
    assert route_task("Create docker file") == ModelType.LAGUNA
    assert route_task("Write bash script") == ModelType.LAGUNA
    assert route_task("Build CLI tool") == ModelType.LAGUNA


def test_speed_routing():
    """Test speed-critical task routing."""
    assert route_task("Quick code") == ModelType.DEEPSEEK
    assert route_task("Fast implementation") == ModelType.DEEPSEEK


def test_context_routing():
    """Test large context task routing."""
    assert route_task("Analyze code", context_size=500000) == ModelType.NEMOTRON
    assert route_task("Analyze code", context_size=100000) != ModelType.NEMOTRON


def test_local_routing():
    """Test local-only task routing."""
    assert route_task("Run locally", is_local_only=True) == ModelType.NORTH


def test_default_routing():
    """Test default task routing."""
    assert route_task("Write function") == ModelType.LING
    assert route_task("Create API") == ModelType.LING


def test_empty_description():
    """Test empty description raises error."""
    with pytest.raises(ValueError):
        route_task("")


def test_model_info():
    """Test model info retrieval."""
    for model in ModelType:
        info = get_model_info(model)
        assert "name" in info
        assert "provider" in info
        assert "strength" in info


def test_model_info_unknown():
    """Test unknown model returns empty dict."""
    info = get_model_info("unknown")
    assert info == {}


# Run tests
if __name__ == "__main__":
    pytest.main([__file__, "-v"])