package cli

import (
	"path/filepath"
	"time"

	"github.com/spf13/afero"
)

// gatherVaultStats collects statistics from all vaults
func gatherVaultStats(
	fs afero.Fs,
	vaultsDir string,
) (totalSecrets int, totalSize int64, oldestTime, latestTime time.Time, err error) {
	vaultEntries, err := afero.ReadDir(fs, vaultsDir)
	if err != nil {
		return 0, 0, time.Time{}, time.Time{}, err
	}

	for _, vaultEntry := range vaultEntries {
		if !vaultEntry.IsDir() {
			continue
		}

		vaultPath := filepath.Join(vaultsDir, vaultEntry.Name())
		secretsPath := filepath.Join(vaultPath, "secrets.d")

		// Count secrets in this vault
		secretEntries, err := afero.ReadDir(fs, secretsPath)
		if err != nil {
			continue
		}

		for _, secretEntry := range secretEntries {
			if !secretEntry.IsDir() {
				continue
			}

			totalSecrets++
			secretPath := filepath.Join(secretsPath, secretEntry.Name())

			// Get size and timestamps from all versions
			versionsPath := filepath.Join(secretPath, "versions")
			versionEntries, err := afero.ReadDir(fs, versionsPath)
			if err != nil {
				continue
			}

			for _, versionEntry := range versionEntries {
				if !versionEntry.IsDir() {
					continue
				}

				versionPath := filepath.Join(versionsPath, versionEntry.Name())

				// Add size of encrypted data
				dataPath := filepath.Join(versionPath, "data.age")
				if stat, err := fs.Stat(dataPath); err == nil {
					totalSize += stat.Size()
				}

				// Add size of metadata
				metaPath := filepath.Join(versionPath, "metadata.age")
				if stat, err := fs.Stat(metaPath); err == nil {
					totalSize += stat.Size()
				}

				// Track timestamps
				if stat, err := fs.Stat(versionPath); err == nil {
					modTime := stat.ModTime()
					if oldestTime.IsZero() || modTime.Before(oldestTime) {
						oldestTime = modTime
					}
					if latestTime.IsZero() || modTime.After(latestTime) {
						latestTime = modTime
					}
				}
			}
		}
	}

	return totalSecrets, totalSize, oldestTime, latestTime, nil
}