warpbox/cmd/cmd_box.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/spf13/cobra"
	"github.com/spf13/pflag"
	"golang.org/x/crypto/bcrypt"

	"warpbox/lib/boxstore"
	"warpbox/lib/helpers"
	"warpbox/lib/models"
)

func newBoxCommand() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "box",
		Short: "Manage boxes",
		Long:  "Manage WarpBox upload boxes: list, view, inspect, delete, modify.",
	}

	cmd.AddCommand(newBoxListCommand())
	cmd.AddCommand(newBoxViewCommand())
	cmd.AddCommand(newBoxInspectCommand())
	cmd.AddCommand(newBoxDeleteCommand())
	cmd.AddCommand(newBoxChangeCommand())
	cmd.AddCommand(newBoxGetCommand())

	return cmd
}

func newBoxListCommand() *cobra.Command {
	var format string
	var uploadRoot string
	var sortBy string
	var sortOrder string
	var filterExpired string
	var filterPassword string
	var filterOneTime string
	var filterSizeMin string
	var filterSizeMax string
	var filterCreatedAfter string
	var filterCreatedBefore string
	cmd := &cobra.Command{
		Use:     "ls",
		Aliases: []string{"list", "view"},
		Short:   "List all boxes",
		Long:    "List all boxes with optional sorting and filtering.",
		RunE: func(cmd *cobra.Command, args []string) error {
			if uploadRoot != "" {
				boxstore.SetUploadRoot(uploadRoot)
			}
			summaries, err := boxstore.ListBoxSummaries()
			if err != nil {
				return fmt.Errorf("failed to list boxes: %w", err)
			}
			if len(summaries) == 0 {
				fmt.Println("No boxes found.")
				return nil
			}

			// Apply filters
			summaries = filterBoxes(summaries, filterExpired, filterPassword, filterOneTime, filterSizeMin, filterSizeMax, filterCreatedAfter, filterCreatedBefore)

			if len(summaries) == 0 {
				fmt.Println("No boxes match the given filters.")
				return nil
			}

			// Apply sorting
			sortBoxes(summaries, sortBy, sortOrder)

			switch format {
			case "json":
				return formatBoxSummariesJSON(summaries)
			case "table", "":
				return formatBoxSummariesTable(summaries)
			default:
				return fmt.Errorf("unknown format: %s (use 'table' or 'json')", format)
			}
		},
	}
	cmd.Flags().StringVarP(&format, "format", "o", "table", "Output format: table, json")
	cmd.Flags().StringVar(&uploadRoot, "upload-root", "", "Override upload root directory")
	cmd.Flags().StringVar(&sortBy, "sort", "created", "Sort field: created, expires, size, files")
	cmd.Flags().StringVar(&sortOrder, "sort-order", "desc", "Sort order: asc, desc")
	cmd.Flags().StringVar(&filterExpired, "filter-expired", "", "Filter by expiry: yes, no, all")
	cmd.Flags().StringVar(&filterPassword, "filter-password", "", "Filter by password: yes, no, all")
	cmd.Flags().StringVar(&filterOneTime, "filter-one-time", "", "Filter by one-time: yes, no, all")
	cmd.Flags().StringVar(&filterSizeMin, "filter-size-min", "", "Minimum total size in bytes (e.g. 1024, 1k, 1m, 1g)")
	cmd.Flags().StringVar(&filterSizeMax, "filter-size-max", "", "Maximum total size in bytes (e.g. 1024, 1k, 1m, 1g)")
	cmd.Flags().StringVar(&filterCreatedAfter, "filter-created-after", "", "Only boxes created after this time (RFC3339)")
	cmd.Flags().StringVar(&filterCreatedBefore, "filter-created-before", "", "Only boxes created before this time (RFC3339)")
	return cmd
}

func filterBoxes(summaries []models.BoxSummary, filterExpired, filterPassword, filterOneTime, filterSizeMin, filterSizeMax, filterCreatedAfter, filterCreatedBefore string) []models.BoxSummary {
	result := make([]models.BoxSummary, 0, len(summaries))

	minSize, _ := parseSizeFilter(filterSizeMin)
	maxSize, _ := parseSizeFilter(filterSizeMax)
	createdAfter, _ := time.Parse(time.RFC3339, filterCreatedAfter)
	createdBefore, _ := time.Parse(time.RFC3339, filterCreatedBefore)

	for _, s := range summaries {
		if filterExpired != "" && filterExpired != "all" {
			match := "no"
			if s.Expired {
				match = "yes"
			}
			if match != filterExpired {
				continue
			}
		}
		if filterPassword != "" && filterPassword != "all" {
			match := "no"
			if s.PasswordProtected {
				match = "yes"
			}
			if match != filterPassword {
				continue
			}
		}
		if filterOneTime != "" && filterOneTime != "all" {
			match := "no"
			if s.OneTimeDownload {
				match = "yes"
			}
			if match != filterOneTime {
				continue
			}
		}
		if minSize > 0 && s.TotalSize < minSize {
			continue
		}
		if maxSize > 0 && s.TotalSize > maxSize {
			continue
		}
		if !createdAfter.IsZero() && s.CreatedAt.Before(createdAfter) {
			continue
		}
		if !createdBefore.IsZero() && !s.CreatedAt.Before(createdBefore) {
			continue
		}
		result = append(result, s)
	}
	return result
}

func parseSizeFilter(s string) (int64, error) {
	if s == "" {
		return 0, nil
	}
	s = strings.TrimSpace(s)
	lower := strings.ToLower(s)

	multiplier := int64(1)
	switch {
	case strings.HasSuffix(lower, "g"):
		multiplier = 1024 * 1024 * 1024
		s = strings.TrimSuffix(lower, "g")
	case strings.HasSuffix(lower, "m"):
		multiplier = 1024 * 1024
		s = strings.TrimSuffix(lower, "m")
	case strings.HasSuffix(lower, "k"):
		multiplier = 1024
		s = strings.TrimSuffix(lower, "k")
	}

	val, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return 0, fmt.Errorf("invalid size filter: %s", s)
	}
	return val * multiplier, nil
}

func sortBoxes(summaries []models.BoxSummary, sortBy, sortOrder string) {
	reverse := false
	if strings.EqualFold(sortOrder, "desc") {
		reverse = true
	}

	sort.SliceStable(summaries, func(i, j int) bool {
		var less bool
		switch strings.ToLower(sortBy) {
		case "size":
			less = summaries[i].TotalSize < summaries[j].TotalSize
		case "files":
			less = summaries[i].FileCount < summaries[j].FileCount
		case "expires":
			// Boxes with no expiry go last
			iZero := summaries[i].ExpiresAt.IsZero()
			jZero := summaries[j].ExpiresAt.IsZero()
			if iZero && jZero {
				return false
			}
			if iZero {
				return false
			}
			if jZero {
				return true
			}
			less = summaries[i].ExpiresAt.Before(summaries[j].ExpiresAt)
		case "created", "":
			less = summaries[i].CreatedAt.Before(summaries[j].CreatedAt)
		default:
			less = summaries[i].ID < summaries[j].ID
		}
		if reverse {
			return !less
		}
		return less
	})
}

func newBoxViewCommand() *cobra.Command {
	var uploadRoot string
	var asJSON bool
	cmd := &cobra.Command{
		Use:   "view",
		Short: "View box summary",
		Long:  "View a box summary showing files, size, expiry, etc.",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			if uploadRoot != "" {
				boxstore.SetUploadRoot(uploadRoot)
			}
			boxID := args[0]
			summary, err := boxstore.BoxSummary(boxID)
			if err != nil {
				return fmt.Errorf("failed to view box %s: %w", boxID, err)
			}
			if asJSON {
				return formatBoxSummaryJSON(&summary)
			}
			printBoxSummary(&summary)
			return nil
		},
	}
	cmd.Flags().StringVar(&uploadRoot, "upload-root", "", "Override upload root directory")
	cmd.Flags().BoolVar(&asJSON, "json", false, "Output as JSON")
	return cmd
}

func newBoxInspectCommand() *cobra.Command {
	var uploadRoot string
	var full bool
	var asJSON bool
	cmd := &cobra.Command{
		Use:   "inspect",
		Short: "Inspect box manifest (raw JSON)",
		Long:  "Print the full box manifest as JSON. Use --full for hidden fields.",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			if uploadRoot != "" {
				boxstore.SetUploadRoot(uploadRoot)
			}
			boxID := args[0]
			manifest, err := boxstore.ReadManifest(boxID)
			if err != nil {
				return fmt.Errorf("failed to read manifest for box %s: %w", boxID, err)
			}
			if !full {
				sanitized := manifest
				sanitized.PasswordHash = "[REDACTED]"
				sanitized.PasswordSalt = "[REDACTED]"
				sanitized.AuthToken = "[REDACTED]"
				manifest = sanitized
			}
			enc := json.NewEncoder(os.Stdout)
			enc.SetIndent("", "  ")
			return enc.Encode(manifest)
		},
	}
	cmd.Flags().StringVar(&uploadRoot, "upload-root", "", "Override upload root directory")
	cmd.Flags().BoolVar(&full, "full", false, "Show sensitive fields (password hash, auth token)")
	cmd.Flags().BoolVar(&asJSON, "json", false, "Output as JSON (default for inspect)")
	_ = asJSON // inspect is always JSON; flag kept for consistency
	return cmd
}

func newBoxDeleteCommand() *cobra.Command {
	var uploadRoot string
	var force bool
	var asJSON bool
	cmd := &cobra.Command{
		Use:     "rm",
		Aliases: []string{"del", "delete"},
		Short:   "Delete a box",
		Args:    cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			if uploadRoot != "" {
				boxstore.SetUploadRoot(uploadRoot)
			}
			boxID := args[0]
			if !force {
				fmt.Printf("This will permanently delete box %s and all its files.\n", boxID)
				fmt.Print("Confirm (y/N): ")
				var confirm string
				if _, err := fmt.Scanln(&confirm); err != nil {
					confirm = "n"
				}
				if strings.ToLower(strings.TrimSpace(confirm)) != "y" {
					if asJSON {
						fmt.Println(`{"deleted": false, "reason": "aborted"}`)
					} else {
						fmt.Println("Aborted.")
					}
					return nil
				}
			}
			if err := boxstore.DeleteBox(boxID); err != nil {
				if asJSON {
					fmt.Printf(`{"deleted": false, "error": "%s"}\n`, strings.ReplaceAll(err.Error(), `"`, `\"`))
				} else {
					return fmt.Errorf("failed to delete box %s: %w", boxID, err)
				}
				return nil
			}
			if asJSON {
				fmt.Printf(`{"deleted": true, "box_id": "%s"}\n`, boxID)
			} else {
				fmt.Printf("Box %s deleted.\n", boxID)
			}
			return nil
		},
	}
	cmd.Flags().StringVar(&uploadRoot, "upload-root", "", "Override upload root directory")
	cmd.Flags().BoolVarP(&force, "force", "f", false, "Skip confirmation prompt")
	cmd.Flags().BoolVar(&asJSON, "json", false, "Output as JSON")
	return cmd
}

func newBoxChangeCommand() *cobra.Command {
	var uploadRoot string
	var retention int64
	var retentionList bool
	var password string
	var zip bool
	var oneTime bool
	var renew bool
	var renewSeconds int64
	var asJSON bool

	cmd := &cobra.Command{
		Use:     "change",
		Aliases: []string{"update", "modify"},
		Short:   "Change box properties",
		Long:    "Change box properties: retention, password, zip, one-time download, renew expiry.",
		Args:    cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			if uploadRoot != "" {
				boxstore.SetUploadRoot(uploadRoot)
			}
			boxID := args[0]

			if retentionList {
				printRetentionOptions()
				return nil
			}

			changes, err := gatherBoxChanges(cmd.Flags(), retention, password, zip, oneTime, renew, renewSeconds)
			if err != nil {
				return err
			}

			if len(changes) == 0 {
				fmt.Println("No changes specified. Use --retention, --password, --zip, --one-time, --renew, or --retention-list.")
				return nil
			}

			manifest, err := boxstore.ReadManifest(boxID)
			if err != nil {
				return fmt.Errorf("failed to read manifest for box %s: %w", boxID, err)
			}

			for _, apply := range changes {
				if err := apply(&manifest); err != nil {
					return err
				}
			}

			if err := boxstore.WriteManifest(boxID, manifest); err != nil {
				return fmt.Errorf("failed to save manifest for box %s: %w", boxID, err)
			}

			if asJSON {
				return formatChangeResultJSON(boxID, manifest)
			}
			fmt.Printf("Box %s updated.\n", boxID)
			return nil
		},
	}

	cmd.Flags().StringVar(&uploadRoot, "upload-root", "", "Override upload root directory")
	cmd.Flags().Int64Var(&retention, "retention", 0, "Set retention seconds (use --retention-list for valid values)")
	cmd.Flags().BoolVar(&retentionList, "retention-list", false, "List available retention options")
	cmd.Flags().StringVar(&password, "password", "", "Set a new password (empty string to remove)")
	cmd.Flags().BoolVar(&zip, "zip", true, "Allow ZIP downloads (default true, --zip=false to disable)")
	cmd.Flags().BoolVar(&oneTime, "one-time", false, "Enable one-time download mode")
	cmd.Flags().BoolVar(&renew, "renew", false, "Renew box expiry (use --renew-seconds for duration)")
	cmd.Flags().Int64Var(&renewSeconds, "renew-seconds", 0, "Seconds to extend expiry by (used with --renew)")
	cmd.Flags().BoolVar(&asJSON, "json", false, "Output as JSON")

	return cmd
}

type changeFunc func(*models.BoxManifest) error

func gatherBoxChanges(flags *pflag.FlagSet, retention int64, password string, zip bool, oneTime bool, renew bool, renewSeconds int64) ([]changeFunc, error) {
	var changes []changeFunc

	if flags.Changed("retention") {
		if retention < 0 {
			return nil, fmt.Errorf("retention cannot be negative")
		}
		changes = append(changes, func(m *models.BoxManifest) error {
			if m.OneTimeDownload {
				m.OneTimeDownload = false
			}
			m.RetentionSecs = retention
			for _, opt := range boxstore.RetentionOptions() {
				if opt.Seconds == retention {
					m.RetentionKey = opt.Key
					m.RetentionLabel = opt.Label
					return nil
				}
			}
			m.RetentionKey = "custom"
			return nil
		})
	}

	if flags.Changed("password") {
		changes = append(changes, func(m *models.BoxManifest) error {
			if password == "" {
				m.PasswordHash = ""
				m.PasswordHashAlg = ""
				m.AuthToken = ""
				return nil
			}
			token, err := helpers.RandomHexID(16)
			if err != nil {
				return fmt.Errorf("could not generate auth token")
			}
			hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
			if err != nil {
				return fmt.Errorf("could not hash password: %w", err)
			}
			m.PasswordHash = string(hash)
			m.PasswordHashAlg = "bcrypt"
			m.AuthToken = token
			return nil
		})
	}

	if flags.Changed("zip") {
		changes = append(changes, func(m *models.BoxManifest) error {
			if m.OneTimeDownload {
				return nil
			}
			m.DisableZip = !zip
			return nil
		})
	}

	if flags.Changed("one-time") {
		changes = append(changes, func(m *models.BoxManifest) error {
			if oneTime {
				m.OneTimeDownload = true
				m.DisableZip = false
				if boxstore.OneTimeDownloadExpiry() > 0 {
					m.RetentionSecs = boxstore.OneTimeDownloadExpiry()
				}
			} else {
				m.OneTimeDownload = false
			}
			return nil
		})
	}

	if flags.Changed("renew") {
		changes = append(changes, func(m *models.BoxManifest) error {
			secs := renewSeconds
			if secs <= 0 {
				secs = m.RetentionSecs
			}
			return renewBoxExpiry(m, secs)
		})
	}

	return changes, nil
}

func renewBoxExpiry(m *models.BoxManifest, seconds int64) error {
	if seconds <= 0 || m.OneTimeDownload {
		return nil
	}
	if m.ExpiresAt.IsZero() {
		m.ExpiresAt = time.Now().UTC().Add(time.Duration(seconds) * time.Second)
		return nil
	}
	m.ExpiresAt = m.ExpiresAt.Add(time.Duration(seconds) * time.Second)
	return nil
}

func newBoxGetCommand() *cobra.Command {
	var uploadRoot string
	var asJSON bool
	cmd := &cobra.Command{
		Use:   "get",
		Short: "Get box URL and info",
		Args:  cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			if uploadRoot != "" {
				boxstore.SetUploadRoot(uploadRoot)
			}
			boxID := args[0]
			manifest, err := boxstore.ReadManifest(boxID)
			if err != nil {
				return fmt.Errorf("failed to read manifest for box %s: %w", boxID, err)
			}

			if asJSON {
				return formatBoxGetJSON(boxID, manifest)
			}

			fmt.Printf("Box ID:\t%s\n", boxID)
			fmt.Printf("URL:\t/box/%s\n", boxID)
			if !manifest.CreatedAt.IsZero() {
				fmt.Printf("Created:\t%s\n", manifest.CreatedAt.Format(time.RFC3339))
			}
			if !manifest.ExpiresAt.IsZero() {
				fmt.Printf("Expires:\t%s\n", manifest.ExpiresAt.Format(time.RFC3339))
			}
			if boxstore.IsPasswordProtected(manifest) {
				fmt.Println("Password:\tprotected")
			}
			if manifest.OneTimeDownload {
				fmt.Println("Mode:\tone-time download")
			}
			return nil
		},
	}
	cmd.Flags().StringVar(&uploadRoot, "upload-root", "", "Override upload root directory")
	cmd.Flags().BoolVar(&asJSON, "json", false, "Output as JSON")
	return cmd
}