package docker

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"testing"
	"time"
)

// TestIntegrationInfo dijalankan hanya bila docker socket tersedia —
// di CI runner tanpa socket, test di-skip otomatis.
func TestIntegrationInfo(t *testing.T) {
	if _, err := os.Stat("/var/run/docker.sock"); err != nil {
		t.Skip("docker socket tidak ada — skip tes integrasi")
	}
	c, err := New()
	if err != nil {
		t.Fatalf("New: %v", err)
	}
	defer c.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := c.Ping(ctx); err != nil {
		t.Fatalf("Ping: %v", err)
	}
	info, err := c.Info(ctx)
	if err != nil {
		t.Fatalf("Info: %v", err)
	}
	if info.ServerVersion == "" {
		t.Fatal("ServerVersion kosong")
	}
	t.Logf("engine %s (API %s) · %d/%d kontainer berjalan · %d image · %d CPU · %d MB RAM",
		info.ServerVersion, info.APIVersion, info.Running, info.Containers,
		info.Images, info.CPUs, info.MemoryTotal/1024/1024)

	items, err := c.ListContainers(ctx)
	if err != nil {
		t.Fatalf("ListContainers: %v", err)
	}
	t.Logf("ListContainers: %d kontainer", len(items))
	for i, ct := range items {
		if i >= 5 {
			break
		}
		t.Logf("  - %-20s %-10s %s", ct.Name, ct.State, ct.Image)
	}

	images, err := c.ListImages(ctx)
	if err != nil {
		t.Fatalf("ListImages: %v", err)
	}
	volumes, err := c.ListVolumes(ctx)
	if err != nil {
		t.Fatalf("ListVolumes: %v", err)
	}
	networks, err := c.ListNetworks(ctx)
	if err != nil {
		t.Fatalf("ListNetworks: %v", err)
	}
	t.Logf("images=%d volumes=%d networks=%d", len(images), len(volumes), len(networks))
	for _, ct := range items {
		if ct.State != "running" {
			continue
		}
		if b, err := c.InspectJSON(ctx, ct.ID); err != nil || len(b) == 0 {
			t.Fatalf("InspectJSON(%s): err=%v len=%d", ct.Name, err, len(b))
		}
		if env, err := c.InspectEnv(ctx, ct.ID); err != nil || len(env) == 0 {
			t.Fatalf("InspectEnv(%s): err=%v n=%d", ct.Name, err, len(env))
		}
		titles, rows, err := c.TopProcesses(ctx, ct.ID)
		if err != nil || len(titles) == 0 || len(rows) == 0 {
			t.Fatalf("TopProcesses(%s): err=%v titles=%d rows=%d", ct.Name, err, len(titles), len(rows))
		}
		t.Logf("inspect+env+top OK untuk %s (%d proses)", ct.Name, len(rows))
		break
	}
}

// TestIntegrationEvents — stream event daemon: buat volume unik via CLI,
// tunggu event `create`-nya muncul. Butuh docker CLI + socket.
func TestIntegrationEvents(t *testing.T) {
	if _, err := os.Stat("/var/run/docker.sock"); err != nil {
		t.Skip("docker socket tidak ada")
	}
	if _, err := exec.LookPath("docker"); err != nil {
		t.Skip("docker CLI tidak ada")
	}
	c, err := New()
	if err != nil {
		t.Fatalf("New: %v", err)
	}
	defer c.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()
	ch := c.StreamEvents(ctx)
	time.Sleep(400 * time.Millisecond) // beri waktu stream tersambung

	name := fmt.Sprintf("tiae2e%d", os.Getpid())
	if out, err := exec.Command("docker", "volume", "create", name).CombinedOutput(); err != nil {
		t.Skipf("docker volume create gagal: %v (%s)", err, out)
	}
	defer exec.Command("docker", "volume", "rm", name).Run() //nolint:errcheck

	deadline := time.After(8 * time.Second)
	for {
		select {
		case ev, ok := <-ch:
			if !ok {
				t.Fatal("stream event tertutup lebih awal")
			}
			if ev.Type == "volume" && ev.Actor == name && ev.Action == "create" {
				t.Logf("event diterima: %s %s '%s'", ev.At.Format("15:04:05"), ev.Action, ev.Actor)
				return
			}
		case <-deadline:
			t.Fatal("event volume create tidak diterima dalam 8 dtk")
		}
	}
}