package internal

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

// ContainerInfo holds Docker container details.
type ContainerInfo struct {
	ID      string `json:"ID"`
	Name    string `json:"Names"`
	Image   string `json:"Image"`
	Status  string `json:"Status"`
	State   string `json:"State"`
	Ports   string `json:"Ports"`
	Created string `json:"CreatedAt"`
}

// RunOptions configures docker run.
type RunOptions struct {
	Network string
	Ports   map[int]int       // host:container
	Volumes map[string]string // host:container
	Env     map[string]string
	Restart string // "always", "unless-stopped"
	Detach  bool
	Command []string
}

// ListContainers returns all Docker containers.
func ListContainers() ([]*ContainerInfo, error) {
	out, err := exec.Command("docker", "ps", "-a", "--format", "{{json .}}").Output()
	if err != nil {
		return nil, fmt.Errorf("docker ps: %w", err)
	}

	var containers []*ContainerInfo
	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
		if line == "" {
			continue
		}
		var c ContainerInfo
		if err := json.Unmarshal([]byte(line), &c); err != nil {
			continue
		}
		containers = append(containers, &c)
	}
	return containers, nil
}

// RunContainer starts a new Docker container.
func RunContainer(name, image string, opts RunOptions) error {
	args := []string{"run"}
	if opts.Detach {
		args = append(args, "-d")
	}
	args = append(args, "--name", name)

	if opts.Network != "" {
		args = append(args, "--network", opts.Network)
	}
	if opts.Restart != "" {
		args = append(args, "--restart", opts.Restart)
	}
	for host, container := range opts.Ports {
		args = append(args, "-p", fmt.Sprintf("%d:%d", host, container))
	}
	for host, container := range opts.Volumes {
		args = append(args, "-v", host+":"+container)
	}
	for k, v := range opts.Env {
		args = append(args, "-e", k+"="+v)
	}

	args = append(args, image)
	args = append(args, opts.Command...)

	cmd := exec.Command("docker", args...)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("docker run: %s: %w", strings.TrimSpace(string(out)), err)
	}
	return nil
}

// StopContainer stops a running container.
func StopContainer(name string) error {
	cmd := exec.Command("docker", "stop", name)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("docker stop: %s: %w", strings.TrimSpace(string(out)), err)
	}
	return nil
}

// StartContainer starts a stopped container.
func StartContainer(name string) error {
	cmd := exec.Command("docker", "start", name)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("docker start: %s: %w", strings.TrimSpace(string(out)), err)
	}
	return nil
}

// RemoveContainer removes a container.
func RemoveContainer(name string) error {
	cmd := exec.Command("docker", "rm", "-f", name)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("docker rm: %s: %w", strings.TrimSpace(string(out)), err)
	}
	return nil
}

// BuildImage builds a Docker image from a context path.
// If dockerfilePath is non-empty, it specifies the Dockerfile location relative to contextPath.
func BuildImage(contextPath, tag string, dockerfilePath ...string) error {
	args := []string{"build", "-t", tag}
	if len(dockerfilePath) > 0 && dockerfilePath[0] != "" {
		args = append(args, "-f", dockerfilePath[0])
	}
	args = append(args, contextPath)
	cmd := exec.Command("docker", args...)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return fmt.Errorf("docker build: %s: %w", strings.TrimSpace(string(out)), err)
	}
	return nil
}

// ContainerLogs returns recent log output.
func ContainerLogs(name string, lines int) (string, error) {
	if lines <= 0 {
		lines = 50
	}
	cmd := exec.Command("docker", "logs", "--tail", fmt.Sprintf("%d", lines), name)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return "", fmt.Errorf("docker logs: %w", err)
	}
	return string(out), nil
}

// InspectContainer returns container details.
func InspectContainer(name string) (*ContainerInfo, error) {
	out, err := exec.Command("docker", "inspect", "--format",
		`{{.State.Status}}|{{.State.StartedAt}}|{{.Config.Image}}`, name).Output()
	if err != nil {
		return nil, fmt.Errorf("docker inspect: %w", err)
	}
	parts := strings.SplitN(strings.TrimSpace(string(out)), "|", 3)
	state := ""
	status := ""
	image := ""
	if len(parts) >= 1 {
		state = parts[0]
	}
	if len(parts) >= 2 {
		status = formatUptime(parts[1])
	}
	if len(parts) >= 3 {
		image = parts[2]
	}
	return &ContainerInfo{
		Name:   name,
		State:  state,
		Status: status,
		Image:  image,
	}, nil
}

// formatUptime converts a Docker StartedAt timestamp into a human-readable uptime.
func formatUptime(startedAt string) string {
	t, err := time.Parse(time.RFC3339Nano, startedAt)
	if err != nil {
		return ""
	}
	d := time.Since(t)
	switch {
	case d < time.Minute:
		return fmt.Sprintf("%ds", int(d.Seconds()))
	case d < time.Hour:
		return fmt.Sprintf("%dm", int(d.Minutes()))
	case d < 24*time.Hour:
		h := int(d.Hours())
		m := int(d.Minutes()) % 60
		if m == 0 {
			return fmt.Sprintf("%dh", h)
		}
		return fmt.Sprintf("%dh %dm", h, m)
	default:
		days := int(d.Hours()) / 24
		h := int(d.Hours()) % 24
		if h == 0 {
			return fmt.Sprintf("%dd", days)
		}
		return fmt.Sprintf("%dd %dh", days, h)
	}
}

// IsContainerRunning checks if a container is in running state.
func IsContainerRunning(name string) bool {
	out, err := exec.Command("docker", "inspect", "-f", "{{.State.Running}}", name).Output()
	if err != nil {
		return false
	}
	return strings.TrimSpace(string(out)) == "true"
}

// containerIP returns the IP address of a Docker container.
func containerIP(name string) string {
	out, err := exec.Command("docker", "inspect", "-f",
		"{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}", name).Output()
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(out))
}