package cli

import (
	"context"
	"fmt"
	"io"

	"banger/internal/daemon/workspace"
)

// runWorkspaceDryRun inspects the local repo at resolvedPath and
// prints the file list that `vm run` / `workspace prepare` would ship
// into the guest. Runs on the CLI side (no daemon RPC needed) since
// the daemon is always local and the workspace inspection is a pure
// git read.
func runWorkspaceDryRun(ctx context.Context, out io.Writer, resolvedPath, branchName, fromRef string, includeUntracked bool) error {
	spec, err := workspace.InspectRepo(ctx, resolvedPath, branchName, fromRef, includeUntracked)
	if err != nil {
		return err
	}
	fmt.Fprintf(out, "dry-run: %d file(s) would be copied to guest\n", len(spec.OverlayPaths))
	fmt.Fprintf(out, "repo: %s\n", spec.RepoRoot)
	if includeUntracked {
		fmt.Fprintln(out, "mode: tracked + untracked non-ignored (--include-untracked)")
	} else {
		fmt.Fprintln(out, "mode: tracked only (re-run with --include-untracked to also copy untracked non-ignored files)")
	}
	fmt.Fprintln(out, "---")
	for _, path := range spec.OverlayPaths {
		fmt.Fprintln(out, path)
	}
	if !includeUntracked {
		if err := noteUntrackedSkipped(ctx, out, spec.RepoRoot); err != nil {
			return err
		}
	}
	return nil
}

// noteUntrackedSkipped prints a one-line notice to stderr-analog when
// the repo has untracked non-ignored files that will NOT be copied
// because --include-untracked was not passed. Silent when there are
// no such files, or when the count can't be determined.
func noteUntrackedSkipped(ctx context.Context, out io.Writer, repoRoot string) error {
	count, err := workspace.CountUntrackedPaths(ctx, repoRoot)
	if err != nil {
		return err
	}
	if count == 0 {
		return nil
	}
	fmt.Fprintf(out, "---\nnote: %d untracked non-ignored file(s) were NOT copied (git-tracked files only by default — pass --include-untracked to include them)\n", count)
	return nil
}