package cli

import (
	"context"
	"flag"
	"fmt"
	"os"
	"path"
	"text/tabwriter"

	"github.com/davis7dotsh/tx9/internal/box"
	"github.com/davis7dotsh/tx9/internal/docker"
)

func cmdMount(args []string) error {
	if len(args) == 0 {
		return fmt.Errorf("mount: action required (usage: tx9 mount <add|list|remove> ...)")
	}
	switch args[0] {
	case "add":
		return cmdMountAdd(args[1:])
	case "list":
		return cmdMountList(args[1:])
	case "remove", "rm":
		return cmdMountRemove(args[1:])
	default:
		return fmt.Errorf("mount: unknown action %q (usage: tx9 mount <add|list|remove> ...)", args[0])
	}
}

func cmdMountAdd(args []string) error {
	fs := flag.NewFlagSet("mount add", flag.ContinueOnError)
	readOnly := fs.Bool("read-only", false, "mount read-only inside the agent container")
	requireMountpoint := fs.Bool("require-mountpoint", false, "refuse recreation unless the source is an active host mountpoint")
	if err := parseFlagsAnywhere(fs, args); err != nil {
		return err
	}
	if fs.NArg() != 3 {
		return fmt.Errorf("mount add: expected box, host source, and container target (usage: tx9 mount add <box> <source> <target>)")
	}
	name, source, target := fs.Arg(0), fs.Arg(1), fs.Arg(2)
	mount, err := box.NewAgentMount(source, target, *readOnly, *requireMountpoint)
	if err != nil {
		return fmt.Errorf("mount add %s: %w", name, err)
	}

	return withBoxLock(name, func(ctx context.Context, cli *docker.Client) error {
		b, err := box.Get(ctx, cli, name)
		if err != nil {
			return fmt.Errorf("mount add %s: %w", name, err)
		}
		mounts, err := box.LoadAgentMounts(name)
		if err != nil {
			return fmt.Errorf("mount add %s: %w", name, err)
		}
		for _, existing := range mounts {
			if existing.Target != mount.Target {
				continue
			}
			if existing == mount {
				// Idempotent no-op: recreating the agent here would kill
				// in-flight agent work for zero configuration change.
				fmt.Printf("tx9: mount already configured for %s; nothing to do\n", name)
				return nil
			}
			return fmt.Errorf("mount add %s: target %s is already configured from %s; remove it first", name, mount.Target, existing.Source)
		}
		mounts = append(mounts, mount)
		if err := applyAgentMounts(ctx, cli, b, name, mounts); err != nil {
			return fmt.Errorf("mount add %s: %w", name, err)
		}
		fmt.Printf("tx9: mounted %s at %s in %s (%s)\n", mount.Source, mount.Target, name, mountMode(mount))
		return nil
	})
}

func cmdMountList(args []string) error {
	fs := flag.NewFlagSet("mount list", flag.ContinueOnError)
	if err := parseFlagsAnywhere(fs, args); err != nil {
		return err
	}
	name, err := requireBoxName(fs, "mount list")
	if err != nil {
		return err
	}
	return withDocker(func(ctx context.Context, cli *docker.Client) error {
		if _, err := box.Get(ctx, cli, name); err != nil {
			return fmt.Errorf("mount list %s: %w", name, err)
		}
		mounts, err := box.LoadAgentMounts(name)
		if err != nil {
			return fmt.Errorf("mount list %s: %w", name, err)
		}
		if len(mounts) == 0 {
			fmt.Printf("tx9: no agent mounts configured for %s\n", name)
			return nil
		}
		w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
		fmt.Fprintln(w, "SOURCE\tTARGET\tMODE\tREQUIRE MOUNTPOINT")
		for _, mount := range mounts {
			fmt.Fprintf(w, "%s\t%s\t%s\t%t\n", mount.Source, mount.Target, mountMode(mount), mount.RequireMountpoint)
		}
		return w.Flush()
	})
}

func cmdMountRemove(args []string) error {
	fs := flag.NewFlagSet("mount remove", flag.ContinueOnError)
	if err := parseFlagsAnywhere(fs, args); err != nil {
		return err
	}
	if fs.NArg() != 2 {
		return fmt.Errorf("mount remove: expected box and container target (usage: tx9 mount remove <box> <target>)")
	}
	name, target := fs.Arg(0), path.Clean(fs.Arg(1))

	return withBoxLock(name, func(ctx context.Context, cli *docker.Client) error {
		b, err := box.Get(ctx, cli, name)
		if err != nil {
			return fmt.Errorf("mount remove %s: %w", name, err)
		}
		mounts, err := box.LoadAgentMounts(name)
		if err != nil {
			return fmt.Errorf("mount remove %s: %w", name, err)
		}
		kept := mounts[:0]
		found := false
		for _, mount := range mounts {
			if mount.Target == target {
				found = true
				continue
			}
			kept = append(kept, mount)
		}
		if !found {
			// Idempotent no-op (or a typo'd target): never recreate the
			// agent when the desired mount set did not change.
			fmt.Printf("tx9: no configured mount at %s; nothing to do\n", target)
			return nil
		}
		if err := applyAgentMounts(ctx, cli, b, name, kept); err != nil {
			return fmt.Errorf("mount remove %s: %w", name, err)
		}
		fmt.Printf("tx9: removed mount at %s from %s\n", target, name)
		return nil
	})
}

// applyAgentMounts recreates the agent with the desired mount set and only
// then persists it, so state and container cannot diverge in a way a retry
// of the same command would skip: a recreation failure leaves the old state
// (the retry is not an idempotent no-op), and a persisted set always
// describes a container that actually carried it.
func applyAgentMounts(ctx context.Context, cli *docker.Client, b *box.Box, name string, mounts []box.AgentMount) error {
	token, err := box.Token(b.Name)
	if err != nil {
		return err
	}
	wasRunning, err := box.RecreateAgent(ctx, cli, b, token, mounts)
	if err != nil {
		return err
	}
	if err := box.SaveAgentMounts(name, mounts); err != nil {
		return fmt.Errorf("agent was recreated with the desired mounts but persisting them failed; re-run the command: %w", err)
	}
	if !wasRunning {
		return nil
	}
	// A quiesced box (e.g. freshly imported, single-writer safety gate) must
	// stay quiesced: PrepareRuntime runs `hb up`, which clears the quiesce
	// marker and wires MCP — exactly what cmd_import deliberately avoids.
	// An inconclusive check is an error, not "active": guessing wrong would
	// unquiesce the box. The mounts themselves are already applied and
	// saved; the box's own workload loop reconciles the runtime regardless.
	quiesced, err := box.AgentQuiesced(ctx, cli, b, token)
	if err != nil {
		return fmt.Errorf("mounts are applied, but could not determine whether the box is quiesced; skipped runtime preparation: %w", err)
	}
	if quiesced {
		fmt.Println("tx9: box is quiesced; skipping runtime preparation (run `hb resume` inside the box when ready)")
		return nil
	}
	fmt.Println("tx9: preparing recreated agent runtime")
	return box.PrepareRuntime(ctx, cli, b, token, os.Stdout)
}

func mountMode(mount box.AgentMount) string {
	if mount.ReadOnly {
		return "ro"
	}
	return "rw"
}