import json
import os
import sys
from pathlib import Path

HERMES_DIR = Path(os.getenv("HERMES_HOME", "/data/.hermes"))
CONFIG_FILE = HERMES_DIR / "config.yaml"
ENV_FILE = Path("/data/.env")


def load_env():
    env = {}
    if not ENV_FILE.exists():
        return env
    for line in ENV_FILE.read_text().splitlines():
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        if "=" in line:
            key, _, val = line.partition("=")
            env[key.strip()] = val.strip()
            os.environ[key.strip()] = val.strip()
    return env


def build_config(env):
    provider = env.get("HERMES_PROVIDER", "openai")
    model = env.get("HERMES_MODEL", "gpt-4o")

    config_parts = []

    model_section = "model:\n  provider: {}\n  default: \"{}\"".format(provider, model)
    config_parts.append(model_section)

    providers_lines = ["providers:"]

    provider_configs = {
        "openai": {
            "name": "openai",
            "base_url": env.get("OPENAI_BASE_URL", env.get("OPENAI_API_BASE", "https://api.openai.com/v1")),
            "key_env": "OPENAI_API_KEY",
            "models": [model],
        },
        "anthropic": {
            "name": "anthropic",
            "base_url": env.get("ANTHROPIC_BASE_URL", "https://api.anthropic.com"),
            "key_env": "ANTHROPIC_API_KEY",
            "models": [model],
        },
        "deepseek": {
            "name": "deepseek",
            "base_url": env.get("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1"),
            "key_env": "DEEPSEEK_API_KEY",
            "models": [model],
        },
        "gemini": {
            "name": "gemini",
            "base_url": env.get("GEMINI_BASE_URL", "https://generativelanguage.googleapis.com/v1beta/openai"),
            "key_env": "GEMINI_API_KEY",
            "models": [model],
        },
        "openrouter": {
            "name": "openrouter",
            "base_url": env.get("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1"),
            "key_env": "OPENROUTER_API_KEY",
            "models": [model],
        },
    }

    for pname, pcfg in provider_configs.items():
        key = os.getenv(pcfg["key_env"], "")
        placeholder = "sk-your-{}-key-here".format(pname)
        if key and key != placeholder:
            providers_lines.append("  {}:".format(pcfg["name"]))
            providers_lines.append("    name: {}".format(pcfg["name"]))
            providers_lines.append("    base_url: {}".format(pcfg["base_url"]))
            providers_lines.append("    key_env: {}".format(pcfg["key_env"]))
            providers_lines.append("    transport: openai_chat")
            providers_lines.append('    default_model: "{}"'.format(pcfg["models"][0]))
            providers_lines.append("    models:")
            for m in pcfg["models"]:
                providers_lines.append('      "{}":'.format(m))

    i = 1
    while True:
        prefix = "CUSTOM_{}".format(i)
        name = env.get("{}_NAME".format(prefix), "")
        if not name:
            break
        base_url = env.get("{}_BASE_URL".format(prefix), "").rstrip("/")
        key_env = "{}_API_KEY".format(prefix)
        default_model = env.get("{}_DEFAULT_MODEL".format(prefix), "")
        if base_url and os.getenv(key_env) and default_model:
            providers_lines.append("  {}:".format(name))
            providers_lines.append("    name: {}".format(name))
            providers_lines.append("    base_url: {}".format(base_url))
            providers_lines.append("    key_env: {}".format(key_env))
            providers_lines.append("    transport: openai_chat")
            providers_lines.append('    default_model: "{}"'.format(default_model))
            providers_lines.append("    models:")
            providers_lines.append('      "{}":'.format(default_model))
        i += 1

    if len(providers_lines) > 1:
        config_parts.append("\n".join(providers_lines))

    config_parts.append("terminal:\n  backend: local")

    telegram_token = env.get("TELEGRAM_BOT_TOKEN", "")
    if telegram_token and telegram_token != "YOUR_TELEGRAM_BOT_TOKEN":
        channels = []
        channels.append("channels:")
        channels.append("  telegram:")
        channels.append("    token_env: TELEGRAM_BOT_TOKEN")
        channels.append("    polling: true")
        channels.append("    enabled: true")
        config_parts.append("\n".join(channels))

    return "\n\n".join(config_parts) + "\n"


def main():
    HERMES_DIR.mkdir(parents=True, exist_ok=True)
    for sub in ["sessions", "workspace", "skills", "memory", "agents",
                "credentials", "cache", "logs", "history", "conversations"]:
        (HERMES_DIR / sub).mkdir(parents=True, exist_ok=True)

    env = load_env()
    config = build_config(env)
    CONFIG_FILE.write_text(config, encoding="utf-8")
    print("[start.py] Config written to {}".format(CONFIG_FILE))
    print("[start.py] Provider: {}".format(env.get("HERMES_PROVIDER", "openai")))
    print("[start.py] Model: {}".format(env.get("HERMES_MODEL", "gpt-4o")))
    tg = env.get("TELEGRAM_BOT_TOKEN", "")
    if tg and tg != "YOUR_TELEGRAM_BOT_TOKEN":
        print("[start.py] Telegram: configured")
    else:
        print("[start.py] Telegram: not configured")


if __name__ == "__main__":
    main()