package controllers

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

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

func Services() (string, *ServicesController) {
	return "services", &ServicesController{}
}

type ServicesController struct {
	application.BaseController
}

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

	// Service detail page — identified by repo/service from infra.json
	app.Handle("GET /services/{repo}/{service}", app.Serve("service.html", RequireAuth()))
	app.Handle("POST /services/deploy", app.Method(c, "Deploy", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/stop", app.Method(c, "Stop", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/start", app.Method(c, "Start", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/restart", app.Method(c, "Restart", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/redeploy", app.Method(c, "Redeploy", RequireAuth()))
	app.Handle("GET /services/{repo}/{service}/logs", app.Method(c, "Logs", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/domain", app.Method(c, "SetDomain", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/delete", app.Method(c, "Delete", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/env", app.Method(c, "UpdateEnv", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/settings", app.Method(c, "UpdateSettings", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/run-binary", app.Method(c, "RunBinary", RequireAuth()))
	app.Handle("POST /services/{repo}/{service}/stop-binary", app.Method(c, "StopBinary", RequireAuth()))
	app.Handle("POST /services/{repo}/launch", app.Method(c, "LaunchRemote", RequireAuth()))
}

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

// Service returns the current service from infra.json + Docker state.
func (c *ServicesController) Service() *internal.LocalService {
	repoName := c.PathValue("repo")
	serviceName := c.PathValue("service")
	if repoName == "" || serviceName == "" {
		return nil
	}
	svc, _ := internal.GetService(repoName, serviceName)
	return svc
}

func (c *ServicesController) ServiceUptime() string {
	svc := c.Service()
	if svc == nil {
		return ""
	}
	ct, err := internal.InspectContainer(svc.ContainerName)
	if err != nil {
		return ""
	}
	return ct.Status
}

// ServiceDomainID returns the Domain record ID for DNS check.
func (c *ServicesController) ServiceDomainID() string {
	svc := c.Service()
	if svc == nil {
		return ""
	}
	dom, _ := models.Domains.First("WHERE ContainerName = ?", svc.ContainerName)
	if dom == nil {
		return ""
	}
	return dom.ID
}

// ServiceHistory returns recent log entries for this service.
func (c *ServicesController) ServiceHistory() []*models.LogEntry {
	svc := c.Service()
	if svc == nil {
		return nil
	}
	entries, _ := models.LogEntries.Search(
		"WHERE (Type IN ('deploy', 'start', 'stop', 'restart', 'delete_service')) AND Summary LIKE ? ORDER BY CreatedAt DESC LIMIT 10",
		"%"+svc.Name+"%",
	)
	return entries
}

// AllServices returns all services from all projects' infra.json files.
func (c *ServicesController) AllServices() []internal.LocalService {
	return internal.AllLocalServices()
}

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

// EnvJSON returns the service env as a JSON string (for EnvEditor component).
func (c *ServicesController) EnvJSON() string {
	svc := c.Service()
	if svc == nil || len(svc.Spec.Env) == 0 {
		return "{}"
	}
	data, _ := json.Marshal(svc.Spec.Env)
	return string(data)
}

// VolumesJSON returns the service volumes as a JSON string (for VolumeEditor component).
func (c *ServicesController) VolumesJSON() string {
	svc := c.Service()
	if svc == nil || len(svc.Spec.Volumes) == 0 {
		return "[]"
	}
	// Convert InfraVolumeMount to the format VolumeEditor expects
	type volUI struct {
		Host      string `json:"host"`
		Container string `json:"container"`
	}
	var vols []volUI
	for _, v := range svc.Spec.Volumes {
		vols = append(vols, volUI{Host: v.Source, Container: v.Target})
	}
	data, _ := json.Marshal(vols)
	return string(data)
}

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

func (c *ServicesController) Deploy(w http.ResponseWriter, r *http.Request) {
	repoID := r.FormValue("repo_id")
	if repoID == "" {
		c.RenderError(w, r, fmt.Errorf("select a repository to deploy"))
		return
	}

	repo, err := models.Repositories.Get(repoID)
	if err != nil {
		c.RenderError(w, r, fmt.Errorf("repository not found"))
		return
	}

	// Determine service name — use existing from infra.json or default to "app"
	serviceName := strings.TrimSpace(r.FormValue("service_name"))
	if serviceName == "" {
		serviceName = "app"
	}

	containerPort := 5000
	if cp := r.FormValue("container_port"); cp != "" {
		if parsed, err := strconv.Atoi(cp); err == nil && parsed > 0 && parsed <= 65535 {
			containerPort = parsed
		}
	}

	// Build service spec — no host port mapping by default.
	// All HTTP traffic goes through the reverse proxy on the internal Docker network.
	spec := internal.InfraService{
		Source:  ".",
		Network: "internal",
		Ports: []internal.InfraPort{
			{Container: containerPort},
		},
	}

	// Parse volumes from form if provided
	if volJSON := strings.TrimSpace(r.FormValue("volumes")); volJSON != "" {
		var vols []struct {
			Host      string `json:"host"`
			Container string `json:"container"`
		}
		if json.Unmarshal([]byte(volJSON), &vols) == nil {
			for _, v := range vols {
				if v.Host != "" && v.Container != "" {
					spec.Volumes = append(spec.Volumes, internal.InfraVolumeMount{Source: v.Host, Target: v.Container})
				}
			}
		}
	}

	// Build path
	if bp := strings.TrimSpace(r.FormValue("build_path")); bp != "" && bp != "." {
		spec.Source = bp
	}

	// Check if container already exists
	containerName := internal.ContainerNameFor(repo.Name, serviceName)
	if internal.IsContainerRunning(containerName) {
		c.RenderError(w, r, fmt.Errorf("service %s/%s is already running", repo.Name, serviceName))
		return
	}

	// Write to infra.json
	if err := internal.AddService(repo.Name, serviceName, spec); err != nil {
		c.RenderError(w, r, err)
		return
	}

	// Build and run in background
	imageName := internal.ImageNameFor(repo.Name, serviceName)

	go func() {
		repoLocalPath := internal.LocalRepoPath(repo.Path)
		buildCtx := repoLocalPath
		dockerfilePath := ""
		if spec.Source != "" && spec.Source != "." {
			dockerfilePath = repoLocalPath + "/" + strings.TrimSuffix(spec.Source, "/") + "/Dockerfile"
		}

		if err := internal.BuildImage(buildCtx, imageName, dockerfilePath); err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "deploy",
				Summary: fmt.Sprintf("Deploy failed for %s/%s: %v", repo.Name, serviceName, err),
				Author:  "system",
			})
			return
		}

		internal.RemoveContainer(containerName)
		err := internal.RunContainer(containerName, imageName, internal.RunOptions{
			Network: "internal",
			Ports:   infraExposedPorts(spec.Ports),
			Detach:  true,
			Restart: "unless-stopped",
			Env:     spec.Env,
			Volumes: infraVolumesToMap(spec.Volumes),
		})
		if err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "deploy",
				Summary: fmt.Sprintf("Deploy failed for %s/%s: %v", repo.Name, serviceName, err),
				Author:  "system",
			})
			return
		}

		models.LogEntries.Insert(&models.LogEntry{
			Type:    "deploy",
			Summary: fmt.Sprintf("Deployed %s/%s", repo.Name, serviceName),
			Author:  "system",
		})
	}()

	c.Redirect(w, r, "/")
}

func (c *ServicesController) Stop(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")
	containerName := internal.ContainerNameFor(repoName, serviceName)

	internal.StopContainer(containerName)
	models.LogEntries.Insert(&models.LogEntry{
		Type:    "stop",
		Summary: fmt.Sprintf("Stopped %s/%s", repoName, serviceName),
		Author:  "system",
	})
	c.Refresh(w, r)
}

func (c *ServicesController) Start(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")
	containerName := internal.ContainerNameFor(repoName, serviceName)

	internal.StartContainer(containerName)
	models.LogEntries.Insert(&models.LogEntry{
		Type:    "start",
		Summary: fmt.Sprintf("Started %s/%s", repoName, serviceName),
		Author:  "system",
	})
	c.Refresh(w, r)
}

func (c *ServicesController) Restart(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")
	containerName := internal.ContainerNameFor(repoName, serviceName)

	go func() {
		internal.StopContainer(containerName)
		internal.StartContainer(containerName)
		models.LogEntries.Insert(&models.LogEntry{
			Type:    "restart",
			Summary: fmt.Sprintf("Restarted %s/%s", repoName, serviceName),
			Author:  "system",
		})
	}()
	c.Refresh(w, r)
}

func (c *ServicesController) RunBinary(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")

	svc, err := internal.GetService(repoName, serviceName)
	if err != nil {
		c.RenderError(w, r, err)
		return
	}

	// Stop any existing binary process
	internal.StopBinary(repoName, serviceName)

	go func() {
		source := svc.Spec.Source
		if source == "" {
			source = "."
		}

		if err := internal.BuildBinary(repoName, source, serviceName); err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "deploy",
				Summary: fmt.Sprintf("Binary build failed for %s/%s: %v", repoName, serviceName, err),
				Author:  "system",
			})
			return
		}

		port := svc.ContainerPort
		if port == 0 {
			port = 5000
		}
		env := make(map[string]string)
		for k, v := range svc.Spec.Env {
			env[k] = v
		}
		env["PORT"] = fmt.Sprintf("%d", port)

		if err := internal.RunBinary(repoName, serviceName, env); err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "deploy",
				Summary: fmt.Sprintf("Binary run failed for %s/%s: %v", repoName, serviceName, err),
				Author:  "system",
			})
			return
		}

		models.LogEntries.Insert(&models.LogEntry{
			Type:    "deploy",
			Summary: fmt.Sprintf("Started %s/%s as binary (port %d)", repoName, serviceName, port),
			Author:  "system",
		})
	}()

	c.Refresh(w, r)
}

func (c *ServicesController) StopBinary(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")

	internal.StopBinary(repoName, serviceName)
	models.LogEntries.Insert(&models.LogEntry{
		Type:    "stop",
		Summary: fmt.Sprintf("Stopped binary %s/%s", repoName, serviceName),
		Author:  "system",
	})
	c.Refresh(w, r)
}

func (c *ServicesController) Redeploy(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")

	svc, err := internal.GetService(repoName, serviceName)
	if err != nil {
		c.RenderError(w, r, err)
		return
	}

	repo, _ := models.Repositories.First("WHERE Name = ?", repoName)
	if repo == nil {
		c.RenderError(w, r, fmt.Errorf("repository %s not found", repoName))
		return
	}

	go func() {
		containerName := svc.ContainerName
		repoLocalPath := internal.LocalRepoPath(repo.Path)
		imageName := svc.Image

		buildCtx := repoLocalPath
		dockerfilePath := ""
		if svc.Spec.Source != "" && svc.Spec.Source != "." {
			dockerfilePath = repoLocalPath + "/" + strings.TrimSuffix(svc.Spec.Source, "/") + "/Dockerfile"
		}

		if err := internal.BuildImage(buildCtx, imageName, dockerfilePath); err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "deploy",
				Summary: fmt.Sprintf("Redeploy failed for %s/%s: %v", repoName, serviceName, err),
				Author:  "system",
			})
			return
		}

		internal.StopContainer(containerName)
		internal.RemoveContainer(containerName)

		err := internal.RunContainer(containerName, imageName, internal.RunOptions{
			Network: "internal",
			Ports:   infraExposedPorts(svc.Spec.Ports),
			Detach:  true,
			Restart: "unless-stopped",
			Env:     svc.Spec.Env,
			Volumes: infraVolumesToMap(svc.Spec.Volumes),
		})
		if err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "deploy",
				Summary: fmt.Sprintf("Redeploy failed for %s/%s: %v", repoName, serviceName, err),
				Author:  "system",
			})
			return
		}
		models.LogEntries.Insert(&models.LogEntry{
			Type:    "deploy",
			Summary: fmt.Sprintf("Redeployed %s/%s", repoName, serviceName),
			Author:  "system",
		})
	}()

	c.Refresh(w, r)
}

func (c *ServicesController) Logs(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")

	svc, _ := internal.GetService(repoName, serviceName)
	var logs string
	if svc != nil && svc.Mode == "binary" {
		logs, _ = internal.BinaryLogs(repoName, serviceName, 100)
	} else {
		containerName := internal.ContainerNameFor(repoName, serviceName)
		logs, _ = internal.ContainerLogs(containerName, 100)
	}
	c.Render(w, r, "service-logs.html", logs)
}

func (c *ServicesController) SetDomain(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")
	containerName := internal.ContainerNameFor(repoName, serviceName)

	svc, err := internal.GetService(repoName, serviceName)
	if err != nil {
		c.RenderError(w, r, err)
		return
	}

	domain := strings.TrimSpace(r.FormValue("domain"))

	// Update infra.json with domain
	svc.Spec.Domain = domain
	internal.UpdateService(repoName, serviceName, svc.Spec)

	// For binary services, the reverse proxy routes to the code-server container
	target := containerName
	if svc.Mode == "binary" {
		target = "congo-dev-coder"
	}

	// Update Domain records for reverse proxy routing
	existing, _ := models.Domains.First("WHERE ContainerName = ?", containerName)
	if domain == "" {
		if existing != nil {
			models.Domains.Delete(existing)
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "update_route",
				Summary: fmt.Sprintf("Removed domain from %s/%s", repoName, serviceName),
				Author:  "system",
			})
		}
	} else if existing != nil {
		existing.Host = domain
		existing.Target = target
		existing.Active = true
		models.Domains.Update(existing)
		models.LogEntries.Insert(&models.LogEntry{
			Type:    "update_route",
			Summary: fmt.Sprintf("Updated domain for %s/%s to %s", repoName, serviceName, domain),
			Author:  "system",
		})
	} else {
		cp := svc.ContainerPort
		if cp == 0 {
			cp = 5000
		}
		models.Domains.Insert(&models.Domain{
			Host:          domain,
			Target:        target,
			Port:          cp,
			ContainerName: containerName,
			Active:        true,
		})
		models.LogEntries.Insert(&models.LogEntry{
			Type:    "add_route",
			Summary: fmt.Sprintf("Mapped %s to %s/%s", domain, repoName, serviceName),
			Author:  "system",
		})
	}

	// Add domain to router (validates DNS, provisions TLS)
	if domain != "" {
		if err := router.AllowDomain(domain); err != nil {
			log.Printf("[warn] domain %s: %v", domain, err)
		}
		router.Proxy(domain, fmt.Sprintf("%s:%d", target, svc.ContainerPort))
	}

	c.Refresh(w, r)
}

func (c *ServicesController) Delete(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")
	containerName := internal.ContainerNameFor(repoName, serviceName)

	// Stop any running process (binary or Docker)
	internal.StopBinary(repoName, serviceName)
	internal.StopContainer(containerName)
	internal.RemoveContainer(containerName)

	// Remove domain records and cert allowlist entries
	domains, _ := models.Domains.Search("WHERE ContainerName = ?", containerName)
	for _, d := range domains {
		router.DisallowDomain(d.Host)
		router.RemoveProxy(d.Host)
		models.Domains.Delete(d)
	}

	// Remove from infra.json
	internal.RemoveService(repoName, serviceName)

	models.LogEntries.Insert(&models.LogEntry{
		Type:    "delete_service",
		Summary: fmt.Sprintf("Deleted service %s/%s", repoName, serviceName),
		Author:  "system",
	})
	c.Redirect(w, r, "/")
}

func (c *ServicesController) UpdateEnv(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")

	svc, err := internal.GetService(repoName, serviceName)
	if err != nil {
		c.RenderError(w, r, err)
		return
	}

	envJSON := r.FormValue("env")
	var env map[string]string
	if envJSON != "" {
		json.Unmarshal([]byte(envJSON), &env)
	}
	svc.Spec.Env = env
	internal.UpdateService(repoName, serviceName, svc.Spec)
	c.Refresh(w, r)
}

func (c *ServicesController) UpdateSettings(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")
	serviceName := r.PathValue("service")

	svc, err := internal.GetService(repoName, serviceName)
	if err != nil {
		c.RenderError(w, r, err)
		return
	}

	// Update source/build path
	if bp := strings.TrimSpace(r.FormValue("build_path")); bp != "" {
		svc.Spec.Source = bp
	}

	// Update container (listen) port
	if cp := r.FormValue("container_port"); cp != "" {
		if parsed, err := strconv.Atoi(cp); err == nil && parsed > 0 && parsed <= 65535 {
			if len(svc.Spec.Ports) > 0 {
				svc.Spec.Ports[0].Container = parsed
			} else {
				svc.Spec.Ports = []internal.InfraPort{{Container: parsed}}
			}
			// Update domain record port for reverse proxy routing
			dom, _ := models.Domains.First("WHERE ContainerName = ?", svc.ContainerName)
			if dom != nil {
				dom.Port = parsed
				models.Domains.Update(dom)
			}
		}
	}

	// Update explicit host port exposures (for SMTP, etc.)
	exposePorts := strings.TrimSpace(r.FormValue("expose_ports"))
	// Rebuild ports: keep listen port (first entry, Host=0), add explicit bindings
	listenPort := 5000
	if len(svc.Spec.Ports) > 0 {
		listenPort = svc.Spec.Ports[0].Container
	}
	svc.Spec.Ports = []internal.InfraPort{{Container: listenPort}}
	if exposePorts != "" {
		for _, pair := range strings.Split(exposePorts, ",") {
			pair = strings.TrimSpace(pair)
			parts := strings.SplitN(pair, ":", 2)
			if len(parts) == 2 {
				host, err1 := strconv.Atoi(strings.TrimSpace(parts[0]))
				container, err2 := strconv.Atoi(strings.TrimSpace(parts[1]))
				if err1 == nil && err2 == nil && host > 0 && container > 0 {
					svc.Spec.Ports = append(svc.Spec.Ports, internal.InfraPort{Host: host, Container: container})
				}
			}
		}
	}

	internal.UpdateService(repoName, serviceName, svc.Spec)
	c.Refresh(w, r)
}

func (c *ServicesController) LaunchRemote(w http.ResponseWriter, r *http.Request) {
	repoName := r.PathValue("repo")

	repo, _ := models.Repositories.First("WHERE Name = ?", repoName)
	if repo == nil {
		c.RenderError(w, r, fmt.Errorf("repository %s not found", repoName))
		return
	}

	models.LogEntries.Insert(&models.LogEntry{
		Type:    "launch",
		Summary: fmt.Sprintf("Starting remote deploy of %s...", repoName),
		Author:  "system",
	})

	go func() {
		output, err := internal.CoderExec(fmt.Sprintf(
			"cd /home/coder/repos/%s && congo launch 2>&1 | tail -5", repoName,
		))
		if err != nil {
			models.LogEntries.Insert(&models.LogEntry{
				Type:    "launch",
				Summary: fmt.Sprintf("Remote deploy of %s failed: %v", repoName, err),
				Author:  "system",
			})
			return
		}
		models.LogEntries.Insert(&models.LogEntry{
			Type:    "launch",
			Summary: fmt.Sprintf("Remote deploy of %s completed: %s", repoName, strings.TrimSpace(output)),
			Author:  "system",
		})
	}()

	c.Refresh(w, r)
}

// infraExposedPorts returns only explicitly host-bound ports for docker run -p.
// Most services don't need host ports — the reverse proxy routes via the internal Docker network.
func infraExposedPorts(ports []internal.InfraPort) map[int]int {
	m := make(map[int]int)
	for _, p := range ports {
		if p.Host > 0 {
			m[p.Host] = p.Container
		}
	}
	return m
}

// infraVolumesToMap converts infra.json volume mounts to the map format for RunOptions.
func infraVolumesToMap(vols []internal.InfraVolumeMount) map[string]string {
	if len(vols) == 0 {
		return nil
	}
	m := make(map[string]string)
	for _, v := range vols {
		if v.Source != "" && v.Target != "" {
			m[v.Source] = v.Target
		}
	}
	return m
}