templates.py

"""
Config Templates for Fleet Config Manager.

Pre-built configuration templates for different deployment scenarios.
Each template returns a complete fleet configuration dict that can be
further customized via overrides.
"""

from __future__ import annotations

import copy
from typing import Any


def _deep_merge(base: dict, override: dict) -> dict:
    """Deep-merge override into base, returning a new dict."""
    result = copy.deepcopy(base)
    for key, val in override.items():
        if key in result and isinstance(result[key], dict) and isinstance(val, dict):
            result[key] = _deep_merge(result[key], val)
        else:
            result[key] = copy.deepcopy(val)
    return result


class ConfigTemplates:
    """Pre-built configuration templates for the Pelagic fleet.

    Usage::

        tmpl = ConfigTemplates()
        dev = tmpl.development()
        custom = tmpl.generate("development", overrides={"keeper": {"port": 9000}})
    """

    # -- Base skeleton --------------------------------------------------------

    @staticmethod
    def _base() -> dict[str, Any]:
        return {
            "fleet_name": "pelagic-fleet",
            "version": "1.0.0",
            "environment": "development",
            "keeper": {
                "host": "127.0.0.1",
                "port": 8000,
                "workers": 4,
                "heartbeat_interval": 30,
                "max_agents": 50,
            },
            "agents": {},
            "network": {
                "default_host": "127.0.0.1",
                "base_port": 9000,
                "port_step": 100,
                "allowed_hosts": [],
                "tls_enabled": False,
            },
            "logging": {
                "level": "INFO",
                "format": "json",
                "file": None,
                "max_size_mb": 100,
            },
            "secrets": {},
        }

    # -- Template generators --------------------------------------------------

    def development(self) -> dict[str, Any]:
        """Local development setup — all agents on localhost with debug logging."""
        config = self._base()
        config["environment"] = "development"
        config["logging"]["level"] = "DEBUG"
        config["logging"]["format"] = "text"

        config["agents"] = {
            "git-agent": {
                "name": "git-agent",
                "type": "git",
                "host": "127.0.0.1",
                "port": 9100,
                "enabled": True,
                "env": {"GIT_REPO_PATH": "/tmp/fleet-repo"},
            },
            "chat-agent": {
                "name": "chat-agent",
                "type": "chat",
                "host": "127.0.0.1",
                "port": 9200,
                "enabled": True,
            },
            "lighthouse": {
                "name": "lighthouse",
                "type": "lighthouse",
                "host": "127.0.0.1",
                "port": 9300,
                "enabled": True,
            },
        }
        return config

    def production(self) -> dict[str, Any]:
        """Production setup — separate hosts, TLS, structured logging."""
        config = self._base()
        config["environment"] = "production"
        config["logging"]["level"] = "WARNING"
        config["logging"]["format"] = "json"
        config["network"]["tls_enabled"] = True
        config["network"]["default_host"] = "0.0.0.0"
        config["keeper"]["host"] = "0.0.0.0"
        config["keeper"]["workers"] = 8

        config["agents"] = {
            "git-agent": {
                "name": "git-agent",
                "type": "git",
                "host": "0.0.0.0",
                "port": 9100,
                "enabled": True,
                "env": {"GIT_REPO_PATH": "/data/fleet-repo"},
            },
            "chat-agent": {
                "name": "chat-agent",
                "type": "chat",
                "host": "0.0.0.0",
                "port": 9200,
                "enabled": True,
            },
            "lighthouse": {
                "name": "lighthouse",
                "type": "lighthouse",
                "host": "0.0.0.0",
                "port": 9300,
                "enabled": True,
            },
            "world-agent": {
                "name": "world-agent",
                "type": "world",
                "host": "0.0.0.0",
                "port": 9400,
                "enabled": True,
            },
        }
        return config

    def minimal(self) -> dict[str, Any]:
        """Minimal setup — just Keeper + Git Agent."""
        config = self._base()
        config["environment"] = "development"
        config["keeper"]["max_agents"] = 5

        config["agents"] = {
            "git-agent": {
                "name": "git-agent",
                "type": "git",
                "host": "127.0.0.1",
                "port": 9100,
                "enabled": True,
                "env": {"GIT_REPO_PATH": "/tmp/fleet-repo"},
            },
        }
        return config

    def full(self) -> dict[str, Any]:
        """Full setup — everything enabled."""
        config = self._base()
        config["environment"] = "staging"
        config["network"]["tls_enabled"] = True
        config["keeper"]["workers"] = 6
        config["keeper"]["max_agents"] = 100

        agent_defs = [
            ("git-agent", "git", 9100),
            ("chat-agent", "chat", 9200),
            ("lighthouse", "lighthouse", 9300),
            ("world-agent", "world", 9400),
            ("room-agent", "room", 9500),
            ("scheduler", "scheduler", 9600),
        ]
        config["agents"] = {
            name: {
                "name": name,
                "type": atype,
                "host": "127.0.0.1",
                "port": port,
                "enabled": True,
            }
            for name, atype, port in agent_defs
        }
        return config

    def docker(self) -> dict[str, Any]:
        """Docker-specific settings — internal networking."""
        config = self._base()
        config["environment"] = "production"
        config["keeper"]["host"] = "0.0.0.0"
        config["network"]["default_host"] = "0.0.0.0"
        config["network"]["tls_enabled"] = True
        config["logging"]["level"] = "INFO"

        agent_defs = [
            ("git-agent", "git", 9100),
            ("chat-agent", "chat", 9200),
            ("lighthouse", "lighthouse", 9300),
        ]
        config["agents"] = {
            name: {
                "name": name,
                "type": atype,
                "host": host,
                "port": port,
                "enabled": True,
                "env": {
                    "DOCKER_NETWORK": "fleet-internal",
                    "IMAGE": f"pelagic/{name}:latest",
                },
            }
            for name, atype, port in agent_defs
            for host in [f"{name}"]
        }
        return config

    # -- Generic generator ----------------------------------------------------

    def generate(
        self,
        template_name: str,
        overrides: dict[str, Any] | None = None,
    ) -> dict[str, Any]:
        """Generate a fleet config from a named template + optional overrides.

        Args:
            template_name: One of ``development``, ``production``, ``minimal``,
                           ``full``, ``docker``.
            overrides: Optional dict deep-merged on top of the template.

        Returns:
            Complete fleet configuration dict.

        Raises:
            ValueError: If *template_name* is unknown.
        """
        generators = {
            "development": self.development,
            "production": self.production,
            "minimal": self.minimal,
            "full": self.full,
            "docker": self.docker,
        }
        gen = generators.get(template_name)
        if gen is None:
            available = ", ".join(sorted(generators))
            raise ValueError(
                f"Unknown template '{template_name}'. Available: {available}"
            )
        config = gen()
        if overrides:
            config = _deep_merge(config, overrides)
        return config

    # -- List templates -------------------------------------------------------

    @staticmethod
    def list_templates() -> list[dict[str, str]]:
        """Return metadata about every available template."""
        return [
            {
                "name": "development",
                "description": "Local dev — all on localhost, debug logging",
            },
            {
                "name": "production",
                "description": "Production — separate hosts, TLS, JSON logs",
            },
            {
                "name": "minimal",
                "description": "Minimal — Keeper + Git Agent only",
            },
            {
                "name": "full",
                "description": "Full — all agents enabled",
            },
            {
                "name": "docker",
                "description": "Docker — internal container networking",
            },
        ]