package main

import (
	"bytes"
	"fmt"
	"os"
	"os/exec"
	"regexp"
	"strings"
)

var (
	tmpDir  string
	numeric = regexp.MustCompile(`^[0-9]+$`)
)

func main() {
	if os.Geteuid() != 0 {
		fmt.Fprintf(os.Stderr, "Run this program as root, for example: sudo %s\n", os.Args[0])
		os.Exit(1)
	}

	if _, err := exec.LookPath("whiptail"); err != nil {
		fmt.Fprintln(os.Stderr, "whiptail is required. Install it with: apt install whiptail")
		os.Exit(1)
	}

	var err error
	tmpDir, err = os.MkdirTemp("", "proxmox-toolkit-*")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Could not create temporary directory: %v\n", err)
		os.Exit(1)
	}
	defer os.RemoveAll(tmpDir)

	mainMenu()
}

// menu displays a whiptail menu and returns the selected tag.
// An empty selection means the user cancelled or pressed Esc.
func menu(title, prompt string, height, width, menuHeight int, items ...string) string {
	args := []string{
		"--title", title,
		"--menu", prompt,
		fmt.Sprint(height), fmt.Sprint(width), fmt.Sprint(menuHeight),
	}
	args = append(args, items...)

	return whiptail(args...)
}

// dialog runs whiptail and captures its result through file descriptor 3.
// The menu itself continues to use the terminal.
func whiptail(args ...string) string {
	readEnd, writeEnd, err := os.Pipe()
	if err != nil {
		return ""
	}
	defer readEnd.Close()

	args = append([]string{"--output-fd", "3"}, args...)
	cmd := exec.Command("whiptail", args...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.ExtraFiles = []*os.File{writeEnd}

	err = cmd.Run()
	writeEnd.Close()

	var result bytes.Buffer
	_, _ = result.ReadFrom(readEnd)
	if err != nil {
		return ""
	}
	return strings.TrimSpace(result.String())
}

func message(title, text string) {
	whiptail("--title", title, "--msgbox", text, "8", "70")
}

func confirm(text string) bool {
	return whiptail("--title", "Confirm", "--yesno", text, "10", "70") == ""
}

// Yes/no dialogs also return an empty string on success, so use this
// separate helper to distinguish Yes from No or Esc by the process status.
func confirmAction(text string) bool {
	readEnd, writeEnd, err := os.Pipe()
	if err != nil {
		return false
	}
	defer readEnd.Close()

	cmd := exec.Command(
		"whiptail", "--title", "Confirm", "--yesno", text, "10", "70",
	)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.ExtraFiles = []*os.File{writeEnd}

	err = cmd.Run()
	writeEnd.Close()
	_, _ = readEnd.Read(make([]byte, 1))
	return err == nil
}

func input(title, prompt string) (string, bool) {
	value := whiptail("--title", title, "--inputbox", prompt, "9", "72")
	// An empty value is valid for some prompts, so cancellation is
	// determined by whiptail itself in inputValue below when needed.
	return value, true
}

func inputValue(title, prompt string) (string, bool) {
	readEnd, writeEnd, err := os.Pipe()
	if err != nil {
		return "", false
	}
	defer readEnd.Close()

	cmd := exec.Command("whiptail", "--output-fd", "3",
		"--title", title, "--inputbox", prompt, "9", "72")
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.ExtraFiles = []*os.File{writeEnd}

	err = cmd.Run()
	writeEnd.Close()

	var result bytes.Buffer
	_, _ = result.ReadFrom(readEnd)
	if err != nil {
		return "", false
	}
	return strings.TrimSpace(result.String()), true
}

func requireCommand(name string) bool {
	if _, err := exec.LookPath(name); err != nil {
		message("Command unavailable",
			fmt.Sprintf("The command '%s' is not installed or not available on this node.", name))
		return false
	}
	return true
}

func askID(prompt string) (string, bool) {
	value, ok := inputValue("Enter ID", prompt)
	if !ok {
		return "", false
	}
	if !numeric.MatchString(value) {
		message("Invalid ID", "Enter a numeric VM or container ID.")
		return "", false
	}
	return value, true
}

func showOutput(title string, name string, args ...string) {
	outputPath := tmpDir + "/output.txt"
	output, err := os.Create(outputPath)
	if err != nil {
		message("Error", "Could not create a temporary output file.")
		return
	}

	cmd := exec.Command(name, args...)
	cmd.Stdout = output
	cmd.Stderr = output
	runErr := cmd.Run()
	_ = output.Close()

	data, _ := os.ReadFile(outputPath)
	if len(data) == 0 {
		status := 0
		if runErr != nil {
			status = 1
		}
		data = []byte(fmt.Sprintf("Command completed with exit status %d; no output.\n", status))
	} else if runErr != nil {
		data = append(data, []byte("\nCommand exited with an error.\n")...)
	}
	_ = os.WriteFile(outputPath, data, 0600)

	whiptail("--title", title, "--textbox", outputPath, "24", "85")
}

func vmMenu() {
	for {
		choice := menu("Virtual Machines (QEMU)", "Choose an action:", 16, 72, 8,
			"list", "List VMs (qm list)",
			"config", "Show VM configuration",
			"memory", "Show VM memory setting",
			"unlock", "Unlock a VM",
			"back", "Back",
		)

		switch choice {
		case "list":
			if requireCommand("qm") {
				showOutput("VM list", "qm", "list")
			}
		case "config", "memory", "unlock":
			if !requireCommand("qm") {
				continue
			}
			id, ok := askID("Enter the VMID:")
			if !ok {
				continue
			}

			switch choice {
			case "config":
				showOutput("VM "+id+" configuration", "qm", "config", id)
			case "memory":
				showMemory("VM "+id+" memory", "qm", "config", id, "^memory:")
			case "unlock":
				if confirmAction("Unlock VM " + id + "?\n\nOnly do this if you have confirmed that no task is still running for this VM.") {
					showOutput("Unlock VM "+id, "qm", "unlock", id)
				}
			}
		case "back", "":
			return
		}
	}
}

func showMemory(title, command string, args ...string) {
	output, err := exec.Command(command, args[:len(args)-1]...).CombinedOutput()
	if err != nil {
		showOutput(title, command, args[:len(args)-1]...)
		return
	}

	var matches []string
	for _, line := range strings.Split(string(output), "\n") {
		if matched, _ := regexp.MatchString(args[len(args)-1], line); matched {
			matches = append(matches, line)
		}
	}
	if len(matches) == 0 {
		matches = []string{"No memory setting found."}
	}

	path := tmpDir + "/output.txt"
	_ = os.WriteFile(path, []byte(strings.Join(matches, "\n")+"\n"), 0600)
	whiptail("--title", title, "--textbox", path, "24", "85")
}

func containerMenu() {
	for {
		choice := menu("Containers (LXC)", "Choose an action:", 14, 72, 6,
			"list", "List containers (pct list)",
			"config", "Show container configuration",
			"unlock", "Unlock a container",
			"back", "Back",
		)

		switch choice {
		case "list":
			if requireCommand("pct") {
				showOutput("Container list", "pct", "list")
			}
		case "config", "unlock":
			if !requireCommand("pct") {
				continue
			}
			id, ok := askID("Enter the container ID:")
			if !ok {
				continue
			}
			if choice == "config" {
				showOutput("Container "+id+" configuration", "pct", "config", id)
			} else if confirmAction("Unlock container " + id + "?\n\nOnly do this if you have confirmed that no task is still running for this container.") {
				showOutput("Unlock container "+id, "pct", "unlock", id)
			}
		case "back", "":
			return
		}
	}
}

func backupMenu() {
	if !requireCommand("vzdump") {
		return
	}
	id, ok := askID("Enter the VM or container ID to back up:")
	if !ok {
		return
	}
	if confirmAction("Start a backup for ID " + id + " using vzdump defaults?\n\nReview your node's backup configuration and storage capacity first.") {
		showOutput("Backup ID "+id, "vzdump", id)
	}
}

func restoreMenu() {
	choice := menu("Restore", "Choose what to restore:", 12, 72, 4,
		"vm", "Restore a QEMU VM (qmrestore)",
		"ct", "Restore a container (pct restore)",
		"back", "Back",
	)
	if choice != "vm" && choice != "ct" {
		return
	}

	id, ok := askID("Enter the new VMID or container ID:")
	if !ok {
		return
	}
	archive, ok := inputValue("Backup archive", "Enter the full path to the vzdump archive:")
	if !ok {
		return
	}
	info, err := os.Stat(archive)
	if archive == "" || err != nil || !info.Mode().IsRegular() {
		message("Archive not found", "That file does not exist or is not a regular file.")
		return
	}

	if !confirmAction("Restore '" + archive + "' as ID " + id + "?\n\nRestoring can create or overwrite resources. Confirm the target ID and archive carefully.") {
		return
	}

	if choice == "vm" {
		if requireCommand("qmrestore") {
			showOutput("Restore VM "+id, "qmrestore", archive, id)
		}
	} else if requireCommand("pct") {
		showOutput("Restore container "+id, "pct", "restore", id, archive)
	}
}

func storageMenu() {
	for {
		choice := menu("Storage / LVM", "Choose a read-only report:", 14, 72, 6,
			"pvs", "Physical volumes (pvs)",
			"vgs", "Volume groups (vgs)",
			"lvs", "Logical volumes (lvs)",
			"back", "Back",
		)

		switch choice {
		case "pvs", "vgs", "lvs":
			if requireCommand(choice) {
				showOutput(map[string]string{
					"pvs": "Physical volumes",
					"vgs": "Volume groups",
					"lvs": "Logical volumes",
				}[choice], choice)
			}
		case "back", "":
			return
		}
	}
}

func mainMenu() {
	for {
		choice := menu("Proxmox VE Toolkit", "Select a task:", 21, 76, 13,
			"vms", "Virtual machines (QEMU)",
			"containers", "Containers (LXC)",
			"backup", "Back up a VM or container (vzdump)",
			"restore", "Restore a VM or container",
			"cluster", "Cluster status (pvecm status)",
			"version", "Proxmox version (pveversion -v)",
			"storage", "Storage / LVM reports",
			"perf", "Host performance test (pveperf)",
			"subscription", "Subscription status",
			"dab", "Debian Appliance Builder help",
			"quit", "Exit",
		)

		switch choice {
		case "vms":
			vmMenu()
		case "containers":
			containerMenu()
		case "backup":
			backupMenu()
		case "restore":
			restoreMenu()
		case "cluster":
			if requireCommand("pvecm") {
				showOutput("Cluster status", "pvecm", "status")
			}
		case "version":
			if requireCommand("pveversion") {
				showOutput("Proxmox VE version", "pveversion", "-v")
			}
		case "storage":
			storageMenu()
		case "perf":
			if requireCommand("pveperf") && confirmAction("Run pveperf?\n\nThis can cause temporary disk activity.") {
				showOutput("Host performance", "pveperf")
			}
		case "subscription":
			if requireCommand("pvesubscription") {
				showOutput("Subscription status", "pvesubscription", "get")
			}
		case "dab":
			if requireCommand("dab") {
				showOutput("Debian Appliance Builder help", "dab", "help")
			}
		case "quit", "":
			return
		}
	}
}