package controllers

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"

	"congo.gg/dev/internal"
	"congo.gg/dev/models"
	"congo.gg/pkg/application"
)

func Dashboard() (string, *DashboardController) {
	return "dashboard", &DashboardController{}
}

type DashboardController struct {
	application.BaseController
}

func (c *DashboardController) Setup(app *application.App) {
	c.BaseController.Setup(app)

	// Start code-server
	if err := internal.EnsureCoder(); err != nil {
		fmt.Printf("congo-dev: failed to start code-server: %v\n", err)
	}

	// Sync filesystem repos with DB, then cache infra configs
	go func() {
		internal.SyncFromFilesystem()
		internal.InitInfraCache()
	}()

	// Dashboard (root path)
	app.Handle("GET /{$}", app.Serve("dashboard.html", RequireAuth()))
	app.Handle("GET /getting-started", app.Serve("getting-started.html", RequireAuth()))
	app.Handle("GET /stats", app.Method(c, "Stats", RequireAuth()))
	app.Handle("GET /api/stats", app.Method(c, "APIStats", RequireAuth()))
	app.Handle("GET /api/services/status", app.Method(c, "APIServicesStatus", RequireAuth()))

	// Code-server proxy — auth-wrapped
	// Path-based access at /coder/ and host-based access at code.* subdomain
	coderPathProxy := AuthMiddleware(http.StripPrefix("/coder", internal.CoderProxy()))
	app.Handle("GET /coder/{path...}", coderPathProxy)
	app.Handle("POST /coder/{path...}", coderPathProxy)
	app.Handle("PUT /coder/{path...}", coderPathProxy)
	app.Handle("DELETE /coder/{path...}", coderPathProxy)

	// Code-server management
	app.Handle("POST /coder/restart", app.Method(c, "RestartCoder", RequireAuth()))

	// Domain management
	app.Handle("POST /dashboard/setup-domain", app.Method(c, "SetupDomain", RequireAuth()))

	// Cron management
	app.Handle("GET /cron", app.Method(c, "CronList", RequireAuth()))
	app.Handle("POST /cron/create", app.Method(c, "CronCreate", RequireAuth()))
	app.Handle("POST /cron/delete", app.Method(c, "CronDelete", RequireAuth()))

	// Redirects from old pages to dashboard
	for _, path := range []string{"/services", "/repos", "/routes", "/agent"} {
		app.HandleFunc("GET "+path, func(w http.ResponseWriter, r *http.Request) {
			http.Redirect(w, r, "/", http.StatusSeeOther)
		})
	}
}

// ─── Template methods ───────────────────────────────────────────────────────

func (c *DashboardController) SystemStats() *internal.SystemStats {
	return internal.GetSystemStats()
}

// RunningContainers returns all running Docker containers for dashboard display.
func (c *DashboardController) RunningContainers() []internal.RunningContainer {
	return internal.AllRunningContainers()
}

// Repositories returns all repos ordered by update time.
func (c *DashboardController) Repositories() []*models.Repository {
	repos, _ := models.Repositories.Search("ORDER BY UpdatedAt DESC")
	return repos
}

// AvailableRepos returns repos available for deployment.
func (c *DashboardController) AvailableRepos() []*models.Repository {
	repos, _ := models.Repositories.Search("WHERE Status != 'missing' ORDER BY Name")
	return repos
}

// Routes returns all domain records.
func (c *DashboardController) Routes() []*models.Domain {
	domains, _ := models.Domains.Search("ORDER BY System DESC, Host ASC")
	return domains
}

// Conversations returns recent agent conversations.
func (c *DashboardController) Conversations() []*models.Conversation {
	convs, _ := models.Conversations.Search("ORDER BY UpdatedAt DESC LIMIT 20")
	return convs
}

// HasAgent checks if the Claude Code CLI is authenticated.
func (c *DashboardController) HasAgent() bool {
	return internal.IsAgentAvailable()
}

// ClaudeProcess represents a running Claude Code instance.
type ClaudeProcess struct {
	PID     string
	Command string
	Running bool
}

// ClaudeProcesses checks for running Claude instances in the code-server container.
func (c *DashboardController) ClaudeProcesses() []ClaudeProcess {
	output, err := internal.CoderExec("ps aux | grep '[c]laude' | head -5")
	if err != nil || strings.TrimSpace(output) == "" {
		return nil
	}
	var procs []ClaudeProcess
	for _, line := range strings.Split(strings.TrimSpace(output), "\n") {
		fields := strings.Fields(line)
		if len(fields) < 11 {
			continue
		}
		procs = append(procs, ClaudeProcess{
			PID:     fields[1],
			Command: strings.Join(fields[10:], " "),
			Running: true,
		})
	}
	return procs
}

// ActivityGroup is a set of consecutive log entries with the same type.
type ActivityGroup struct {
	Action string
	Items  []*models.LogEntry
}

// First returns the most recent entry in the group (for timestamps).
func (g ActivityGroup) First() *models.LogEntry { return g.Items[0] }

// Count returns the number of items in the group.
func (g ActivityGroup) Count() int { return len(g.Items) }

// Single returns true if the group has exactly one item.
func (g ActivityGroup) Single() bool { return len(g.Items) == 1 }

// RecentActivity returns log entries grouped by consecutive type.
func (c *DashboardController) RecentActivity() []ActivityGroup {
	entries, _ := models.LogEntries.Search("ORDER BY CreatedAt DESC LIMIT 30")
	if len(entries) == 0 {
		return nil
	}

	var groups []ActivityGroup
	current := ActivityGroup{Action: entries[0].Type, Items: []*models.LogEntry{entries[0]}}

	for _, entry := range entries[1:] {
		if entry.Type == current.Action {
			current.Items = append(current.Items, entry)
		} else {
			groups = append(groups, current)
			current = ActivityGroup{Action: entry.Type, Items: []*models.LogEntry{entry}}
		}
	}
	groups = append(groups, current)

	// Cap to 15 groups
	if len(groups) > 15 {
		groups = groups[:15]
	}
	return groups
}

func (c *DashboardController) IsCoderRunning() bool {
	return internal.IsCoderRunning()
}

func (c *DashboardController) Domain() string {
	return internal.SystemDomain()
}

func (c *DashboardController) HasDomain() bool {
	return internal.SystemDomain() != ""
}

func (c *DashboardController) RepoCount() int {
	count, _ := models.Repositories.Count("")
	return count
}

func (c *DashboardController) RunningServiceCount() int {
	return len(internal.AllRunningContainers())
}

// ServicesByRepo returns a map of repo ID → service count from infra.json.
func (c *DashboardController) ServicesByRepo() map[string]int {
	result := make(map[string]int)
	for _, svc := range internal.AllLocalServices() {
		if svc.RepoID != "" {
			result[svc.RepoID]++
		}
	}
	return result
}

// ActiveTasks returns user-created task checklist items.
func (c *DashboardController) ActiveTasks() []*models.Task {
	tasks, _ := models.Tasks.Search("ORDER BY CreatedAt DESC LIMIT 15")
	return tasks
}

// CronJobs returns cron entries from code-server.
func (c *DashboardController) CronJobs() []internal.CronJob {
	return internal.ListCronJobs()
}

// ─── Handlers ───────────────────────────────────────────────────────────────

func (c *DashboardController) Stats(w http.ResponseWriter, r *http.Request) {
	c.Render(w, r, "system-bar.html", internal.GetSystemStats())
}

func (c *DashboardController) APIStats(w http.ResponseWriter, r *http.Request) {
	stats := internal.GetSystemStats()
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(stats)
}

func (c *DashboardController) APIServicesStatus(w http.ResponseWriter, r *http.Request) {
	containers := internal.AllRunningContainers()
	type status struct {
		Name   string `json:"name"`
		Repo   string `json:"repo"`
		Status string `json:"status"`
		Ports  string `json:"ports"`
		Domain string `json:"domain"`
	}
	var result []status
	for _, ct := range containers {
		result = append(result, status{
			Name:   ct.Name,
			Repo:   ct.RepoName,
			Status: "running",
			Ports:  ct.ShortPorts(),
			Domain: ct.Domain,
		})
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(result)
}

func (c *DashboardController) RestartCoder(w http.ResponseWriter, r *http.Request) {
	go func() {
		internal.CoderRestart()
		models.LogEntries.Insert(&models.LogEntry{
			Type:    "coder_restart",
			Summary: "Restarted VS Code server",
			Author:  "system",
		})
	}()
	c.Refresh(w, r)
}

func (c *DashboardController) CronList(w http.ResponseWriter, r *http.Request) {
	c.Render(w, r, "cron-list.html", internal.ListCronJobs())
}

func (c *DashboardController) CronCreate(w http.ResponseWriter, r *http.Request) {
	schedule := r.FormValue("schedule")
	command := r.FormValue("command")
	comment := r.FormValue("comment")
	if schedule == "" || command == "" {
		c.RenderError(w, r, fmt.Errorf("schedule and command are required"))
		return
	}
	// Basic validation: schedule must have 5 fields
	if len(strings.Fields(schedule)) != 5 {
		c.RenderError(w, r, fmt.Errorf("schedule must have 5 fields (e.g. */5 * * * *)"))
		return
	}
	comment = strings.ReplaceAll(comment, "\n", " ")
	comment = strings.ReplaceAll(comment, "\r", " ")
	if err := internal.AddCronJob(schedule, command, comment); err != nil {
		c.RenderError(w, r, err)
		return
	}
	models.LogEntries.Insert(&models.LogEntry{
		Type:    "cron_create",
		Summary: fmt.Sprintf("Created cron: %s %s", schedule, command),
		Author:  "system",
	})
	c.Render(w, r, "cron-list.html", internal.ListCronJobs())
}

func (c *DashboardController) CronDelete(w http.ResponseWriter, r *http.Request) {
	schedule := r.FormValue("schedule")
	command := r.FormValue("command")
	if err := internal.RemoveCronJob(schedule, command); err != nil {
		c.RenderError(w, r, err)
		return
	}
	models.LogEntries.Insert(&models.LogEntry{
		Type:    "cron_delete",
		Summary: "Removed cron job",
		Author:  "system",
	})
	c.Render(w, r, "cron-list.html", internal.ListCronJobs())
}

func (c *DashboardController) SetupDomain(w http.ResponseWriter, r *http.Request) {
	domain := internal.SystemDomain()
	if domain == "" {
		c.RenderError(w, r, fmt.Errorf("no domain configured"))
		return
	}
	if err := internal.SetupDomain(domain); err != nil {
		c.RenderError(w, r, fmt.Errorf("domain setup failed: %v", err))
		return
	}
	models.LogEntries.Insert(&models.LogEntry{
		Type:    "domain_setup",
		Summary: fmt.Sprintf("Refreshed domain %s", domain),
		Author:  "system",
	})
	c.Refresh(w, r)
}