package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"regexp"

	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/api/types/image"
	"github.com/docker/docker/client"
	"github.com/regclient/regclient"
	"github.com/regclient/regclient/types/ref"
)

// Zerlegt einen Image-Namen in die Form registry/repo:tag für regclient
func parseImageName(imageName string) (string, error) {
	r := regexp.MustCompile(`^(?:(?P<registry>[^/]+)/)?(?P<repo>[^:]+)(?::(?P<tag>.+))?$`)
	match := r.FindStringSubmatch(imageName)
	if len(match) == 0 {
		return "", fmt.Errorf("Fehler beim Parsen des Image-Namens: %s", imageName)
	}
	registry := match[r.SubexpIndex("registry")]
	repo := match[r.SubexpIndex("repo")]
	tag := match[r.SubexpIndex("tag")]
	if repo == "" {
		return "", fmt.Errorf("Kein Repo erkannt in %s", imageName)
	}
	if registry == "" {
		registry = "registry-1.docker.io"
	}
	if tag == "" {
		tag = "latest"
	}
	return fmt.Sprintf("%s/%s:%s", registry, repo, tag), nil
}

// Digest remote ermitteln (regclient)
func getRemoteDigest(ctx context.Context, rc *regclient.RegClient, image string) (string, error) {
	refObj, err := ref.New(image)
	if err != nil {
		return "", fmt.Errorf("image-ref ungültig: %w", err)
	}
	desc, err := rc.ManifestHead(ctx, refObj)
	if err != nil {
		return "", fmt.Errorf("Fehler ManifestHead %s: %w", image, err)
	}
	return desc.GetDigest().String(), nil
}

// Lokalen Digest via Docker-API holen
func getLocalDigestOfImage(ctx context.Context, cli *client.Client, imageName string) (string, error) {
	images, err := cli.ImageList(ctx, image.ListOptions{All: true})
	if err != nil {
		return "", err
	}
	for _, img := range images {
		for _, t := range img.RepoTags {
			if t == imageName {
				if len(img.RepoDigests) > 0 {
					return img.RepoDigests[0], nil
				}
				return img.ID, nil
			}
		}
	}
	return "", fmt.Errorf("Image %s nicht lokal gefunden", imageName)
}

func main() {
	ctx := context.Background()

	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	rc := regclient.New()

	containers, err := cli.ContainerList(ctx, container.ListOptions{All: true})
	if err != nil {
		log.Fatal(err)
	}
	if len(containers) == 0 {
		fmt.Println("Keine laufenden Container gefunden")
		os.Exit(0)
	}

	for _, ctr := range containers {
		fmt.Printf("Container: %s %s (status: %s)\n", ctr.ID[:12], ctr.Image, ctr.Status)
		imageFull, err := parseImageName(ctr.Image)
		if err != nil {
			fmt.Printf("   Fehler beim Parsen des Image-Namens: %v\n", err)
			continue
		}

		localDigest, err := getLocalDigestOfImage(ctx, cli, ctr.Image)
		if err != nil {
			fmt.Printf("   Fehler beim lokalen Digest: %v\n", err)
			continue
		}

		remoteDigest, err := getRemoteDigest(ctx, rc, imageFull)
		if err != nil {
			fmt.Printf("   Fehler beim Remote-Digest: %v\n", err)
			continue
		}

		fmt.Println("   Local Digest: ", localDigest)
		fmt.Println("   Remote Digest:", remoteDigest)
		if localDigest == remoteDigest {
			fmt.Println("   -> Image ist aktuell")
		} else {
			fmt.Println("   -> Update verfügbar!\n")
		}
	}
}