package internal

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

// 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.
func BuildImage(contextPath, tag string) error {
	cmd := exec.Command("docker", "build", "-t", tag, contextPath)
	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", "{{json .}}", name).Output()
	if err != nil {
		return nil, fmt.Errorf("docker inspect: %w", err)
	}
	// Just return basic info
	return &ContainerInfo{
		Name:  name,
		State: strings.TrimSpace(string(out)),
	}, nil
}

// 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"
}