package cli

import (
	"context"
	"flag"
	"fmt"
	"os"
	"strings"

	"github.com/davis7dotsh/tx9/internal/assets"
	"github.com/davis7dotsh/tx9/internal/docker"
	"github.com/davis7dotsh/tx9/internal/lock"
	"github.com/davis7dotsh/tx9/internal/state"
)

// parseFlagsAnywhere parses fs accepting flags before or after positional
// arguments (stdlib flag stops at the first positional, which silently
// ignores trailing flags like `tx9 delete mybox --force`). Everything after
// a literal "--" stays positional.
func parseFlagsAnywhere(fs *flag.FlagSet, args []string) error {
	var flags, positionals []string
	rest := false
	for i := 0; i < len(args); i++ {
		a := args[i]
		switch {
		case rest || a == "-" || len(a) == 0 || a[0] != '-':
			positionals = append(positionals, a)
		case a == "--":
			rest = true
		default:
			flags = append(flags, a)
			// a bool flag never consumes the next arg; others do unless
			// written as -name=value
			name := strings.TrimLeft(a, "-")
			if eq := strings.IndexByte(name, '='); eq >= 0 {
				name = name[:eq]
			} else if f := fs.Lookup(name); f != nil {
				if bf, ok := f.Value.(interface{ IsBoolFlag() bool }); !ok || !bf.IsBoolFlag() {
					if i+1 < len(args) {
						i++
						flags = append(flags, args[i])
					}
				}
			}
		}
	}
	return fs.Parse(append(flags, positionals...))
}

// requireBoxName returns fs's sole positional argument as a box name, or an
// actionable usage error if it's missing or if there's more than one (e.g.
// `tx9 delete mybox typo --force` used to silently delete mybox and ignore
// the extra "typo" positional).
func requireBoxName(fs *flag.FlagSet, cmd string) (string, error) {
	if fs.NArg() != 1 {
		return "", fmt.Errorf("expected exactly one box name (usage: tx9 %s <box>)", cmd)
	}
	return fs.Arg(0), nil
}

// withDocker opens a Docker Engine API client from the environment, runs
// fn, and always closes the client afterward.
func withDocker(fn func(ctx context.Context, cli *docker.Client) error) error {
	ctx := context.Background()
	cli, err := docker.NewClient(ctx)
	if err != nil {
		return err
	}
	defer cli.Close()
	return fn(ctx, cli)
}

// withBoxLock acquires the named box's non-blocking per-box operation lock
// (dossier §8.1: fail fast, never queue two concurrent tx9 operations
// against the same box), then runs fn with a connected Docker client. The
// lock is released and the client closed on return.
func withBoxLock(name string, fn func(ctx context.Context, cli *docker.Client) error) error {
	lockPath, err := state.LockPath(name)
	if err != nil {
		return err
	}
	release, err := lock.Acquire(lockPath)
	if err != nil {
		return err
	}
	defer release()

	return withDocker(fn)
}

// ensureBoxImage builds tag (e.g. "tx9-box:<version>") if the local image
// store doesn't already have it. Shared by create and upgrade: both need a
// current-version image on hand before creating containers from it, and
// the first build is the slow part (~10 min) either way.
func ensureBoxImage(ctx context.Context, cli *docker.Client, tag string) error {
	haveImage, err := cli.ImageExists(ctx, tag)
	if err != nil {
		return err
	}
	if haveImage {
		return nil
	}
	fmt.Printf("tx9: building %s (first build takes ~10 min; cached after)\n", tag)
	buildCtx, err := assets.BuildContextTar(BuildContext)
	if err != nil {
		return err
	}
	return cli.BuildImage(ctx, buildCtx, tag, os.Stdout)
}