vaultik/internal/vaultik/info.go

package vaultik

import (
	"encoding/json"
	"fmt"
	"runtime"
	"sort"
	"strings"

	"git.eeqj.de/sneak/vaultik/internal/log"
	"git.eeqj.de/sneak/vaultik/internal/snapshot"
	"github.com/dustin/go-humanize"
)

// ShowInfo displays system and configuration information
func (v *Vaultik) ShowInfo() error {
	// System Information
	v.printfStdout("=== System Information ===\n")
	v.printfStdout("OS/Architecture: %s/%s\n", runtime.GOOS, runtime.GOARCH)
	v.printfStdout("Version:         %s\n", v.Globals.Version)
	v.printfStdout("Commit:          %s\n", v.Globals.Commit)
	v.printfStdout("Go Version:      %s\n", runtime.Version())
	v.printlnStdout()

	// Storage Configuration
	v.printfStdout("=== Storage Configuration ===\n")
	v.printfStdout("S3 Bucket:       %s\n", v.Config.S3.Bucket)
	if v.Config.S3.Prefix != "" {
		v.printfStdout("S3 Prefix:       %s\n", v.Config.S3.Prefix)
	}
	v.printfStdout("S3 Endpoint:     %s\n", v.Config.S3.Endpoint)
	v.printfStdout("S3 Region:       %s\n", v.Config.S3.Region)
	v.printlnStdout()

	// Backup Settings
	v.printfStdout("=== Backup Settings ===\n")

	// Show configured snapshots
	v.printfStdout("Snapshots:\n")
	for _, name := range v.Config.SnapshotNames() {
		snap := v.Config.Snapshots[name]
		v.printfStdout("  %s:\n", name)
		for _, path := range snap.Paths {
			v.printfStdout("    - %s\n", path)
		}
		if len(snap.Exclude) > 0 {
			v.printfStdout("    exclude: %s\n", strings.Join(snap.Exclude, ", "))
		}
	}

	// Global exclude patterns
	if len(v.Config.Exclude) > 0 {
		v.printfStdout("Global Exclude:  %s\n", strings.Join(v.Config.Exclude, ", "))
	}

	v.printfStdout("Compression:     zstd level %d\n", v.Config.CompressionLevel)
	v.printfStdout("Chunk Size:      %s\n", humanize.Bytes(uint64(v.Config.ChunkSize)))
	v.printfStdout("Blob Size Limit: %s\n", humanize.Bytes(uint64(v.Config.BlobSizeLimit)))
	v.printlnStdout()

	// Encryption Configuration
	v.printfStdout("=== Encryption Configuration ===\n")
	v.printfStdout("Recipients:\n")
	for _, recipient := range v.Config.AgeRecipients {
		v.printfStdout("  - %s\n", recipient)
	}
	v.printlnStdout()

	// Daemon Settings (if applicable)
	if v.Config.BackupInterval > 0 || v.Config.MinTimeBetweenRun > 0 {
		v.printfStdout("=== Daemon Settings ===\n")
		if v.Config.BackupInterval > 0 {
			v.printfStdout("Backup Interval: %s\n", v.Config.BackupInterval)
		}
		if v.Config.MinTimeBetweenRun > 0 {
			v.printfStdout("Minimum Time:    %s\n", v.Config.MinTimeBetweenRun)
		}
		v.printlnStdout()
	}

	// Local Database
	v.printfStdout("=== Local Database ===\n")
	v.printfStdout("Index Path:      %s\n", v.Config.IndexPath)

	// Check if index file exists and get its size
	if info, err := v.Fs.Stat(v.Config.IndexPath); err == nil {
		v.printfStdout("Index Size:      %s\n", humanize.Bytes(uint64(info.Size())))

		// Get snapshot count from database
		query := `SELECT COUNT(*) FROM snapshots WHERE completed_at IS NOT NULL`
		var snapshotCount int
		if err := v.DB.Conn().QueryRowContext(v.ctx, query).Scan(&snapshotCount); err == nil {
			v.printfStdout("Snapshots:       %d\n", snapshotCount)
		}

		// Get blob count from database
		query = `SELECT COUNT(*) FROM blobs`
		var blobCount int
		if err := v.DB.Conn().QueryRowContext(v.ctx, query).Scan(&blobCount); err == nil {
			v.printfStdout("Blobs:           %d\n", blobCount)
		}

		// Get file count from database
		query = `SELECT COUNT(*) FROM files`
		var fileCount int
		if err := v.DB.Conn().QueryRowContext(v.ctx, query).Scan(&fileCount); err == nil {
			v.printfStdout("Files:           %d\n", fileCount)
		}
	} else {
		v.printfStdout("Index Size:      (not created)\n")
	}

	return nil
}

// SnapshotMetadataInfo contains information about a single snapshot's metadata
type SnapshotMetadataInfo struct {
	SnapshotID   string `json:"snapshot_id"`
	ManifestSize int64  `json:"manifest_size"`
	DatabaseSize int64  `json:"database_size"`
	TotalSize    int64  `json:"total_size"`
	BlobCount    int    `json:"blob_count"`
	BlobsSize    int64  `json:"blobs_size"`
}

// RemoteInfoResult contains all remote storage information
type RemoteInfoResult struct {
	// Storage info
	StorageType     string `json:"storage_type"`
	StorageLocation string `json:"storage_location"`

	// Snapshot metadata
	Snapshots          []SnapshotMetadataInfo `json:"snapshots"`
	TotalMetadataSize  int64                  `json:"total_metadata_size"`
	TotalMetadataCount int                    `json:"total_metadata_count"`

	// All blobs on remote
	TotalBlobCount int   `json:"total_blob_count"`
	TotalBlobSize  int64 `json:"total_blob_size"`

	// Referenced blobs (from manifests)
	ReferencedBlobCount int   `json:"referenced_blob_count"`
	ReferencedBlobSize  int64 `json:"referenced_blob_size"`

	// Orphaned blobs
	OrphanedBlobCount int   `json:"orphaned_blob_count"`
	OrphanedBlobSize  int64 `json:"orphaned_blob_size"`
}

// RemoteInfo displays information about remote storage
func (v *Vaultik) RemoteInfo(jsonOutput bool) error {
	log.Info("Starting remote storage info gathering")
	result := &RemoteInfoResult{}

	storageInfo := v.Storage.Info()
	result.StorageType = storageInfo.Type
	result.StorageLocation = storageInfo.Location

	if !jsonOutput {
		v.printfStdout("=== Remote Storage ===\n")
		v.printfStdout("Type:     %s\n", storageInfo.Type)
		v.printfStdout("Location: %s\n", storageInfo.Location)
		v.printlnStdout()
		v.printfStdout("Scanning snapshot metadata...\n")
	}

	snapshotMetadata, snapshotIDs, err := v.collectSnapshotMetadata()
	if err != nil {
		return err
	}

	if !jsonOutput {
		v.printfStdout("Downloading %d manifest(s)...\n", len(snapshotIDs))
	}

	referencedBlobs := v.collectReferencedBlobsFromManifests(snapshotIDs, snapshotMetadata)

	v.populateRemoteInfoResult(result, snapshotMetadata, snapshotIDs, referencedBlobs)

	if err := v.scanRemoteBlobStorage(result, referencedBlobs, jsonOutput); err != nil {
		return err
	}

	log.Info("Remote info complete",
		"snapshots", result.TotalMetadataCount,
		"total_blobs", result.TotalBlobCount,
		"referenced_blobs", result.ReferencedBlobCount,
		"orphaned_blobs", result.OrphanedBlobCount)

	if jsonOutput {
		enc := json.NewEncoder(v.Stdout)
		enc.SetIndent("", "  ")
		return enc.Encode(result)
	}

	v.printRemoteInfoTable(result)
	return nil
}

// collectSnapshotMetadata scans remote metadata and returns per-snapshot info and sorted IDs
func (v *Vaultik) collectSnapshotMetadata() (map[string]*SnapshotMetadataInfo, []string, error) {
	snapshotMetadata := make(map[string]*SnapshotMetadataInfo)

	metadataCh := v.Storage.ListStream(v.ctx, "metadata/")
	for obj := range metadataCh {
		if obj.Err != nil {
			return nil, nil, fmt.Errorf("listing metadata: %w", obj.Err)
		}

		parts := strings.Split(obj.Key, "/")
		if len(parts) < 3 {
			continue
		}
		snapshotID := parts[1]

		if _, exists := snapshotMetadata[snapshotID]; !exists {
			snapshotMetadata[snapshotID] = &SnapshotMetadataInfo{SnapshotID: snapshotID}
		}

		info := snapshotMetadata[snapshotID]
		filename := parts[2]
		if strings.HasPrefix(filename, "manifest") {
			info.ManifestSize = obj.Size
		} else if strings.HasPrefix(filename, "db") {
			info.DatabaseSize = obj.Size
		}
		info.TotalSize = info.ManifestSize + info.DatabaseSize
	}

	var snapshotIDs []string
	for id := range snapshotMetadata {
		snapshotIDs = append(snapshotIDs, id)
	}
	sort.Strings(snapshotIDs)

	return snapshotMetadata, snapshotIDs, nil
}

// collectReferencedBlobsFromManifests downloads manifests and returns referenced blob hashes with sizes
func (v *Vaultik) collectReferencedBlobsFromManifests(snapshotIDs []string, snapshotMetadata map[string]*SnapshotMetadataInfo) map[string]int64 {
	referencedBlobs := make(map[string]int64)

	for _, snapshotID := range snapshotIDs {
		manifestKey := fmt.Sprintf("metadata/%s/manifest.json.zst", snapshotID)
		reader, err := v.Storage.Get(v.ctx, manifestKey)
		if err != nil {
			log.Warn("Failed to get manifest", "snapshot", snapshotID, "error", err)
			continue
		}

		manifest, err := snapshot.DecodeManifest(reader)
		_ = reader.Close()
		if err != nil {
			log.Warn("Failed to decode manifest", "snapshot", snapshotID, "error", err)
			continue
		}

		info := snapshotMetadata[snapshotID]
		info.BlobCount = manifest.BlobCount
		var blobsSize int64
		for _, blob := range manifest.Blobs {
			referencedBlobs[blob.Hash] = blob.CompressedSize
			blobsSize += blob.CompressedSize
		}
		info.BlobsSize = blobsSize
	}

	return referencedBlobs
}

// populateRemoteInfoResult fills in the result's snapshot and referenced blob stats
func (v *Vaultik) populateRemoteInfoResult(result *RemoteInfoResult, snapshotMetadata map[string]*SnapshotMetadataInfo, snapshotIDs []string, referencedBlobs map[string]int64) {
	var totalMetadataSize int64
	for _, id := range snapshotIDs {
		info := snapshotMetadata[id]
		result.Snapshots = append(result.Snapshots, *info)
		totalMetadataSize += info.TotalSize
	}
	result.TotalMetadataSize = totalMetadataSize
	result.TotalMetadataCount = len(snapshotIDs)

	for _, size := range referencedBlobs {
		result.ReferencedBlobCount++
		result.ReferencedBlobSize += size
	}
}

// scanRemoteBlobStorage lists all blobs on remote and computes orphan stats
func (v *Vaultik) scanRemoteBlobStorage(result *RemoteInfoResult, referencedBlobs map[string]int64, jsonOutput bool) error {
	if !jsonOutput {
		v.printfStdout("Scanning blobs...\n")
	}

	blobCh := v.Storage.ListStream(v.ctx, "blobs/")
	allBlobs := make(map[string]int64)

	for obj := range blobCh {
		if obj.Err != nil {
			return fmt.Errorf("listing blobs: %w", obj.Err)
		}
		parts := strings.Split(obj.Key, "/")
		if len(parts) < 4 {
			continue
		}
		hash := parts[3]
		allBlobs[hash] = obj.Size
		result.TotalBlobCount++
		result.TotalBlobSize += obj.Size
	}

	for hash, size := range allBlobs {
		if _, referenced := referencedBlobs[hash]; !referenced {
			result.OrphanedBlobCount++
			result.OrphanedBlobSize += size
		}
	}

	return nil
}

// printRemoteInfoTable renders the human-readable remote info output
func (v *Vaultik) printRemoteInfoTable(result *RemoteInfoResult) {
	v.printfStdout("\n=== Snapshot Metadata ===\n")
	if len(result.Snapshots) == 0 {
		v.printfStdout("No snapshots found\n")
	} else {
		v.printfStdout("%-45s %12s %12s %12s %10s %12s\n", "SNAPSHOT", "MANIFEST", "DATABASE", "TOTAL", "BLOBS", "BLOB SIZE")
		v.printfStdout("%-45s %12s %12s %12s %10s %12s\n", strings.Repeat("-", 45), strings.Repeat("-", 12), strings.Repeat("-", 12), strings.Repeat("-", 12), strings.Repeat("-", 10), strings.Repeat("-", 12))
		for _, info := range result.Snapshots {
			v.printfStdout("%-45s %12s %12s %12s %10s %12s\n",
				truncateString(info.SnapshotID, 45),
				humanize.Bytes(uint64(info.ManifestSize)),
				humanize.Bytes(uint64(info.DatabaseSize)),
				humanize.Bytes(uint64(info.TotalSize)),
				humanize.Comma(int64(info.BlobCount)),
				humanize.Bytes(uint64(info.BlobsSize)),
			)
		}
		v.printfStdout("%-45s %12s %12s %12s %10s %12s\n", strings.Repeat("-", 45), strings.Repeat("-", 12), strings.Repeat("-", 12), strings.Repeat("-", 12), strings.Repeat("-", 10), strings.Repeat("-", 12))
		v.printfStdout("%-45s %12s %12s %12s\n", fmt.Sprintf("Total (%d snapshots)", result.TotalMetadataCount), "", "", humanize.Bytes(uint64(result.TotalMetadataSize)))
	}

	v.printfStdout("\n=== Blob Storage ===\n")
	v.printfStdout("Total blobs on remote:      %s (%s)\n",
		humanize.Comma(int64(result.TotalBlobCount)), humanize.Bytes(uint64(result.TotalBlobSize)))
	v.printfStdout("Referenced by snapshots:    %s (%s)\n",
		humanize.Comma(int64(result.ReferencedBlobCount)), humanize.Bytes(uint64(result.ReferencedBlobSize)))
	v.printfStdout("Orphaned (unreferenced):    %s (%s)\n",
		humanize.Comma(int64(result.OrphanedBlobCount)), humanize.Bytes(uint64(result.OrphanedBlobSize)))

	if result.OrphanedBlobCount > 0 {
		v.printfStdout("\nRun 'vaultik prune --remote' to remove orphaned blobs.\n")
	}
}

// truncateString truncates a string to maxLen, adding "..." if truncated
func truncateString(s string, maxLen int) string {
	if len(s) <= maxLen {
		return s
	}
	if maxLen <= 3 {
		return s[:maxLen]
	}
	return s[:maxLen-3] + "..."
}