package internal

import (
	"encoding/json"
	"fmt"
	"os/exec"
	"strings"
	"time"

	"congo.gg/dev/models"
)

const claudeBin = "/home/coder/.local/bin/claude"

var agentSystemPrompt = `You are the infrastructure assistant for this Congo Dev workbench. You help manage Docker services, git repositories, and server infrastructure.

Available context:
- Docker containers are on the "internal" network
- User services are named "svc-<slug>"
- Code-server runs as "congo-dev-coder"
- Repos are at /home/coder/repos/
- The congo CLI is available for scaffolding projects

Be concise and actionable. When asked to inspect something, do it directly.`

// IsAgentAvailable checks if Claude Code CLI is authenticated in the code-server.
func IsAgentAvailable() bool {
	if !IsCoderRunning() {
		return false
	}
	out, err := CoderExec("test -f /home/coder/.claude/.credentials.json && echo yes")
	if err != nil {
		return false
	}
	return strings.TrimSpace(out) == "yes"
}

// RunAgentChat sends a message to Claude Code CLI and returns the response.
// It builds context about the current infrastructure state and passes it along.
func RunAgentChat(message string) (string, error) {
	if !IsCoderRunning() {
		return "", fmt.Errorf("code-server is not running")
	}

	// Build infrastructure context
	context := buildInfraContext()

	// Construct the prompt with context
	prompt := fmt.Sprintf("%s\n\nCurrent infrastructure state:\n%s\n\nUser request: %s", agentSystemPrompt, context, message)

	// Run claude CLI in print mode with --max-turns 1 for quick responses
	// Use --no-input to prevent interactive prompts
	cmd := exec.Command("docker", "exec", coderContainer,
		claudeBin, "-p", prompt, "--max-turns", "3")
	cmd.Env = append(cmd.Environ(), "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1")

	// Set a timeout
	done := make(chan struct{})
	var out []byte
	var err error
	go func() {
		out, err = cmd.CombinedOutput()
		close(done)
	}()

	select {
	case <-done:
		if err != nil {
			output := strings.TrimSpace(string(out))
			if output != "" {
				return "", fmt.Errorf("claude: %s", output)
			}
			return "", fmt.Errorf("claude: %w", err)
		}
		return strings.TrimSpace(string(out)), nil
	case <-time.After(2 * time.Minute):
		if cmd.Process != nil {
			cmd.Process.Kill()
		}
		return "", fmt.Errorf("claude: timed out after 2 minutes")
	}
}

// buildInfraContext gathers current state to give the agent context.
func buildInfraContext() string {
	var parts []string

	// Containers
	containers, err := ListContainers()
	if err == nil && len(containers) > 0 {
		var names []string
		for _, c := range containers {
			names = append(names, fmt.Sprintf("%s (%s)", c.Name, c.State))
		}
		parts = append(parts, "Containers: "+strings.Join(names, ", "))
	}

	// Repos
	repos, _ := models.Repositories.All()
	if len(repos) > 0 {
		var names []string
		for _, r := range repos {
			names = append(names, r.Name)
		}
		parts = append(parts, "Repos: "+strings.Join(names, ", "))
	}

	// Services
	services, _ := models.Services.All()
	if len(services) > 0 {
		var svcInfo []string
		for _, s := range services {
			status := s.Status
			if IsContainerRunning("svc-" + s.Slug) {
				status = "running"
			}
			svcInfo = append(svcInfo, fmt.Sprintf("%s (%s, port %d)", s.Name, status, s.Port))
		}
		parts = append(parts, "Services: "+strings.Join(svcInfo, ", "))
	}

	// System stats
	stats := GetSystemStats()
	if stats != nil {
		parts = append(parts, fmt.Sprintf("System: %s, %d CPU, mem %s/%s (%d%%), disk %s/%s (%d%%)",
			stats.Hostname, stats.NumCPU,
			stats.MemUsed, stats.MemTotal, stats.MemPercent,
			stats.DiskUsed, stats.DiskTotal, stats.DiskPercent))
	}

	if len(parts) == 0 {
		return "No infrastructure data available"
	}
	return strings.Join(parts, "\n")
}

func toJSON(v any) string {
	data, err := json.MarshalIndent(v, "", "  ")
	if err != nil {
		return fmt.Sprintf("%v", v)
	}
	return string(data)
}