package services

import (
	"archive/zip"
	"fmt"
	"os"
	"path/filepath"
	"testing"
	"time"

	"github.com/Wikid82/charon/backend/internal/config"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestBackupService_CreateAndList(t *testing.T) {
	// Setup temp dirs
	tmpDir, err := os.MkdirTemp("", "cpm-backup-service-test")
	require.NoError(t, err)
	defer func() { _ = os.RemoveAll(tmpDir) }()

	dataDir := filepath.Join(tmpDir, "data")
	err = os.MkdirAll(dataDir, 0o755)
	require.NoError(t, err)

	// Create dummy DB
	dbPath := filepath.Join(dataDir, "charon.db")
	err = os.WriteFile(dbPath, []byte("dummy db"), 0o644)
	require.NoError(t, err)

	// Create dummy caddy dir
	caddyDir := filepath.Join(dataDir, "caddy")
	err = os.MkdirAll(caddyDir, 0o755)
	require.NoError(t, err)
	err = os.WriteFile(filepath.Join(caddyDir, "caddy.json"), []byte("{}"), 0o644)
	require.NoError(t, err)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// Test Create
	filename, err := service.CreateBackup()
	require.NoError(t, err)
	assert.NotEmpty(t, filename)
	assert.FileExists(t, filepath.Join(service.BackupDir, filename))

	// Test List
	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.Len(t, backups, 1)
	assert.Equal(t, filename, backups[0].Filename)
	assert.True(t, backups[0].Size > 0)

	// Test GetBackupPath
	path, err := service.GetBackupPath(filename)
	require.NoError(t, err)
	assert.Equal(t, filepath.Join(service.BackupDir, filename), path)

	// Test Restore
	// Modify DB to verify restore
	err = os.WriteFile(dbPath, []byte("modified db"), 0o644)
	require.NoError(t, err)

	err = service.RestoreBackup(filename)
	require.NoError(t, err)

	// Verify DB content restored
	content, err := os.ReadFile(dbPath)
	require.NoError(t, err)
	assert.Equal(t, "dummy db", string(content))

	// Test Delete
	err = service.DeleteBackup(filename)
	require.NoError(t, err)
	assert.NoFileExists(t, filepath.Join(service.BackupDir, filename))

	// Test Delete Non-existent
	err = service.DeleteBackup("non-existent.zip")
	assert.Error(t, err)
}

func TestBackupService_Restore_ZipSlip(t *testing.T) {
	// Setup temp dirs
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Create malicious zip
	zipPath := filepath.Join(service.BackupDir, "malicious.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	f, err := w.Create("../../../evil.txt")
	require.NoError(t, err)
	_, err = f.Write([]byte("evil"))
	require.NoError(t, err)
	_ = w.Close()
	_ = zipFile.Close()

	// Attempt restore
	err = service.RestoreBackup("malicious.zip")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "illegal file path")
}

func TestBackupService_PathTraversal(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Test GetBackupPath with traversal
	// Should return error
	_, err := service.GetBackupPath("../../etc/passwd")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid filename")

	// Test DeleteBackup with traversal
	// Should return error
	err = service.DeleteBackup("../../etc/passwd")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid filename")
}

func TestBackupService_RunScheduledBackup(t *testing.T) {
	// Setup temp dirs
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	// Create dummy DB
	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("dummy db"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// Run scheduled backup manually
	service.RunScheduledBackup()

	// Verify backup created
	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.Len(t, backups, 1)
}

func TestBackupService_CreateBackup_Errors(t *testing.T) {
	t.Run("missing database file", func(t *testing.T) {
		tmpDir := t.TempDir()
		cfg := &config.Config{DatabasePath: filepath.Join(tmpDir, "nonexistent.db")}
		service := NewBackupService(cfg)
		defer service.Stop() // Prevent goroutine leaks

		_, err := service.CreateBackup()
		assert.Error(t, err)
	})

	t.Run("cannot create backup directory", func(t *testing.T) {
		tmpDir := t.TempDir()
		dbPath := filepath.Join(tmpDir, "charon.db")
		_ = os.WriteFile(dbPath, []byte("test"), 0o644)

		// Create backup dir as a file to cause mkdir error
		backupDir := filepath.Join(tmpDir, "backups")
		_ = os.WriteFile(backupDir, []byte("blocking"), 0o644)

		service := &BackupService{
			DataDir:   tmpDir,
			BackupDir: backupDir,
		}

		_, err := service.CreateBackup()
		assert.Error(t, err)
	})
}

func TestBackupService_RestoreBackup_Errors(t *testing.T) {
	t.Run("non-existent backup", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			DataDir:   filepath.Join(tmpDir, "data"),
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		err := service.RestoreBackup("nonexistent.zip")
		assert.Error(t, err)
	})

	t.Run("invalid zip file", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			DataDir:   filepath.Join(tmpDir, "data"),
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		// Create invalid zip
		badZip := filepath.Join(service.BackupDir, "bad.zip")
		_ = os.WriteFile(badZip, []byte("not a zip"), 0o644)

		err := service.RestoreBackup("bad.zip")
		assert.Error(t, err)
	})
}

func TestBackupService_ListBackups_EmptyDir(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.Empty(t, backups)
}

func TestBackupService_ListBackups_MissingDir(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: filepath.Join(tmpDir, "nonexistent"),
	}

	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.Empty(t, backups)
}

func TestBackupService_CleanupOldBackups(t *testing.T) {
	t.Run("deletes backups exceeding retention", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			DataDir:   filepath.Join(tmpDir, "data"),
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		// Create 10 backup files manually with different timestamps
		for i := 0; i < 10; i++ {
			filename := fmt.Sprintf("backup_2025-01-%02d_10-00-00.zip", i+1)
			zipPath := filepath.Join(service.BackupDir, filename)
			f, err := os.Create(zipPath)
			require.NoError(t, err)
			_ = f.Close()
			// Set modification time to ensure proper ordering
			modTime := time.Date(2025, 1, i+1, 10, 0, 0, 0, time.UTC)
			_ = os.Chtimes(zipPath, modTime, modTime)
		}

		backups, err := service.ListBackups()
		require.NoError(t, err)
		assert.Len(t, backups, 10)

		// Keep only 3 backups
		deleted, err := service.CleanupOldBackups(3)
		require.NoError(t, err)
		assert.Equal(t, 7, deleted)

		// Verify only 3 remain
		backups, err = service.ListBackups()
		require.NoError(t, err)
		assert.Len(t, backups, 3)
	})

	t.Run("keeps all when under retention", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			DataDir:   filepath.Join(tmpDir, "data"),
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		// Create 3 backup files
		for i := 0; i < 3; i++ {
			filename := fmt.Sprintf("backup_2025-01-%02d_10-00-00.zip", i+1)
			zipPath := filepath.Join(service.BackupDir, filename)
			f, err := os.Create(zipPath)
			require.NoError(t, err)
			_ = f.Close()
		}

		// Try to keep 7 - should delete nothing
		deleted, err := service.CleanupOldBackups(7)
		require.NoError(t, err)
		assert.Equal(t, 0, deleted)

		backups, err := service.ListBackups()
		require.NoError(t, err)
		assert.Len(t, backups, 3)
	})

	t.Run("minimum retention of 1", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			DataDir:   filepath.Join(tmpDir, "data"),
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		// Create 5 backup files
		for i := 0; i < 5; i++ {
			filename := fmt.Sprintf("backup_2025-01-%02d_10-00-00.zip", i+1)
			zipPath := filepath.Join(service.BackupDir, filename)
			f, err := os.Create(zipPath)
			require.NoError(t, err)
			_ = f.Close()
			modTime := time.Date(2025, 1, i+1, 10, 0, 0, 0, time.UTC)
			_ = os.Chtimes(zipPath, modTime, modTime)
		}

		// Try to keep 0 - should keep at least 1
		deleted, err := service.CleanupOldBackups(0)
		require.NoError(t, err)
		assert.Equal(t, 4, deleted)

		backups, err := service.ListBackups()
		require.NoError(t, err)
		assert.Len(t, backups, 1)
	})

	t.Run("empty backup directory", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		deleted, err := service.CleanupOldBackups(7)
		require.NoError(t, err)
		assert.Equal(t, 0, deleted)
	})
}

func TestBackupService_GetLastBackupTime(t *testing.T) {
	t.Run("returns latest backup time", func(t *testing.T) {
		tmpDir := t.TempDir()
		dataDir := filepath.Join(tmpDir, "data")
		_ = os.MkdirAll(dataDir, 0o755)

		dbPath := filepath.Join(dataDir, "charon.db")
		_ = os.WriteFile(dbPath, []byte("dummy db"), 0o644)

		cfg := &config.Config{DatabasePath: dbPath}
		service := NewBackupService(cfg)
		defer service.Stop() // Prevent goroutine leaks

		// Create a backup
		_, err := service.CreateBackup()
		require.NoError(t, err)

		lastBackup, err := service.GetLastBackupTime()
		require.NoError(t, err)
		assert.False(t, lastBackup.IsZero())
		assert.WithinDuration(t, time.Now(), lastBackup, 5*time.Second)
	})

	t.Run("returns zero time when no backups", func(t *testing.T) {
		tmpDir := t.TempDir()
		service := &BackupService{
			BackupDir: filepath.Join(tmpDir, "backups"),
		}
		_ = os.MkdirAll(service.BackupDir, 0o755)

		lastBackup, err := service.GetLastBackupTime()
		require.NoError(t, err)
		assert.True(t, lastBackup.IsZero())
	})
}

func TestDefaultBackupRetention(t *testing.T) {
	assert.Equal(t, 7, DefaultBackupRetention)
}

// Phase 1: Critical Coverage Gaps

func TestNewBackupService_BackupDirCreationError(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	// Create a file where backup dir should be to cause mkdir error
	backupDirPath := filepath.Join(dataDir, "backups")
	_ = os.WriteFile(backupDirPath, []byte("blocking"), 0o644)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	// Should not panic even if backup dir creation fails (error is logged, not returned)
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks
	assert.NotNil(t, service)
	// Service is created but backup dir creation failed (logged as error)
}

func TestNewBackupService_CronScheduleError(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	// Service should initialize without panic even if cron has issues
	// (error is logged, not returned)
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks
	assert.NotNil(t, service)
	assert.NotNil(t, service.Cron)
}

func TestRunScheduledBackup_CreateBackupFails(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	// Create a fake database path - don't create the actual file
	dbPath := filepath.Join(dataDir, "charon.db")
	// Important: Don't create the database file, so CreateBackup will fail
	// when it tries to verify the database exists

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// Should not panic when backup fails
	service.RunScheduledBackup()

	// Any zip files that might have been created should be empty or partial
	backups, err := service.ListBackups()
	require.NoError(t, err)
	// CreateBackup creates the file first, then errors if DB doesn't exist
	// So there might be an empty zip file - but no successful backup
	for _, b := range backups {
		// If any backups exist, verify they are empty (0 bytes) as the backup failed
		assert.Equal(t, int64(0), b.Size, "Failed backup should create empty or no zip file")
	}
}

// Phase 2: Error Path Coverage

func TestRunScheduledBackup_CleanupFails(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// Create a backup first
	_, err := service.CreateBackup()
	require.NoError(t, err)

	// Make backup directory read-only to cause cleanup to fail
	_ = os.Chmod(service.BackupDir, 0o444)
	defer func() { _ = os.Chmod(service.BackupDir, 0o755) }() // Restore for cleanup

	// Should not panic when cleanup fails
	service.RunScheduledBackup()

	// Backup creation should have succeeded despite cleanup failure
	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.GreaterOrEqual(t, len(backups), 1)
}

func TestGetLastBackupTime_ListBackupsError(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: filepath.Join(tmpDir, "file_not_dir"),
	}

	// Create a file where directory should be
	_ = os.WriteFile(service.BackupDir, []byte("blocking"), 0o644)

	lastBackup, err := service.GetLastBackupTime()
	assert.Error(t, err)
	assert.True(t, lastBackup.IsZero())
}

// Phase 3: Edge Cases

func TestRunScheduledBackup_CleanupDeletesZero(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// RunScheduledBackup creates 1 backup and tries to cleanup
	// Since we're below DefaultBackupRetention (7), no deletions should occur
	service.RunScheduledBackup()

	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.Equal(t, 1, len(backups))
}

func TestCleanupOldBackups_PartialFailure(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Create 5 backup files
	for i := 0; i < 5; i++ {
		filename := fmt.Sprintf("backup_2025-01-%02d_10-00-00.zip", i+1)
		zipPath := filepath.Join(service.BackupDir, filename)
		f, err := os.Create(zipPath)
		require.NoError(t, err)
		_ = f.Close()
		modTime := time.Date(2025, 1, i+1, 10, 0, 0, 0, time.UTC)
		_ = os.Chtimes(zipPath, modTime, modTime)

		// Make files 0 and 1 read-only to cause deletion to fail
		if i < 2 {
			_ = os.Chmod(zipPath, 0o444)
		}
	}

	// Try to keep only 2 backups (should delete 3, but 2 will fail)
	deleted, err := service.CleanupOldBackups(2)
	require.NoError(t, err)
	// Should delete at least 1 (file 2), files 0 and 1 may fail due to permissions
	assert.GreaterOrEqual(t, deleted, 1)
	assert.LessOrEqual(t, deleted, 3)
}

func TestCreateBackup_CaddyDirMissing(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("dummy db"), 0o644)

	// Explicitly NOT creating caddy directory
	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// Should succeed with warning logged
	filename, err := service.CreateBackup()
	require.NoError(t, err)
	assert.NotEmpty(t, filename)

	// Verify backup contains DB but not caddy/
	backupPath := filepath.Join(service.BackupDir, filename)
	assert.FileExists(t, backupPath)
}

func TestCreateBackup_CaddyDirUnreadable(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("dummy db"), 0o644)

	// Create caddy dir with no read permissions
	caddyDir := filepath.Join(dataDir, "caddy")
	_ = os.MkdirAll(caddyDir, 0o755)
	_ = os.Chmod(caddyDir, 0o000)
	defer func() { _ = os.Chmod(caddyDir, 0o755) }() // Restore for cleanup

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop() // Prevent goroutine leaks

	// Should succeed with warning logged about caddy dir
	filename, err := service.CreateBackup()
	require.NoError(t, err)
	assert.NotEmpty(t, filename)
}

// Phase 4 & 5: Deep Coverage

func TestBackupService_addToZip_FileNotFound(t *testing.T) {
	tmpDir := t.TempDir()
	zipPath := filepath.Join(tmpDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)
	defer func() { _ = zipFile.Close() }()

	w := zip.NewWriter(zipFile)
	defer func() { _ = w.Close() }()

	service := &BackupService{}

	// Try to add non-existent file - should return nil (silent skip)
	err = service.addToZip(w, "/nonexistent/file.txt", "test.txt")
	assert.NoError(t, err, "addToZip should return nil for non-existent files")
}

func TestBackupService_addToZip_FileOpenError(t *testing.T) {
	// Skip this test on root user (e.g., in some CI environments)
	if os.Getuid() == 0 {
		t.Skip("Skipping test that requires non-root user for permission testing")
	}

	tmpDir := t.TempDir()
	zipPath := filepath.Join(tmpDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)
	defer func() { _ = zipFile.Close() }()

	w := zip.NewWriter(zipFile)
	defer func() { _ = w.Close() }()

	// Create a directory (not a file) that cannot be opened as a file
	srcPath := filepath.Join(tmpDir, "unreadable_dir")
	err = os.MkdirAll(srcPath, 0o755)
	require.NoError(t, err)

	// Create a file inside with no read permissions
	unreadablePath := filepath.Join(srcPath, "unreadable.txt")
	err = os.WriteFile(unreadablePath, []byte("test"), 0o000)
	require.NoError(t, err)
	defer func() { _ = os.Chmod(unreadablePath, 0o644) }() // Restore for cleanup

	service := &BackupService{}

	// Should return permission error
	err = service.addToZip(w, unreadablePath, "test.txt")
	assert.Error(t, err)
}

// Additional tests for improved coverage

func TestBackupService_Start(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)

	// Test Start
	service.Start()

	// Verify cron is running (indirectly by checking entries exist)
	entries := service.Cron.Entries()
	assert.NotEmpty(t, entries, "Cron scheduler should have at least one entry")

	// Stop to cleanup
	service.Stop()
}

func TestRunScheduledBackup_CleanupSucceedsWithDeletions(t *testing.T) {
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop()

	// Create more backups than DefaultBackupRetention to trigger cleanup
	for i := 0; i < DefaultBackupRetention+3; i++ {
		filename := fmt.Sprintf("backup_2025-01-%02d_10-00-00.zip", i+1)
		zipPath := filepath.Join(service.BackupDir, filename)
		f, err := os.Create(zipPath)
		require.NoError(t, err)
		_ = f.Close()
		modTime := time.Date(2025, 1, i+1, 10, 0, 0, 0, time.UTC)
		_ = os.Chtimes(zipPath, modTime, modTime)
	}

	// RunScheduledBackup creates a new backup and triggers cleanup
	service.RunScheduledBackup()

	// Verify cleanup happened (should have DefaultBackupRetention backups)
	backups, err := service.ListBackups()
	require.NoError(t, err)
	// The count should be at or around DefaultBackupRetention after cleanup
	assert.LessOrEqual(t, len(backups), DefaultBackupRetention+1)
}

func TestCleanupOldBackups_ListBackupsError(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: filepath.Join(tmpDir, "file_not_dir"),
	}

	// Create a file where directory should be
	_ = os.WriteFile(service.BackupDir, []byte("blocking"), 0o644)

	deleted, err := service.CleanupOldBackups(5)
	assert.Error(t, err)
	assert.Equal(t, 0, deleted)
	assert.Contains(t, err.Error(), "list backups for cleanup")
}

func TestListBackups_EntryInfoError(t *testing.T) {
	// This tests the entry.Info() error path which is hard to trigger
	// The best we can do is test that valid entries work correctly
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Create a valid zip file
	zipPath := filepath.Join(service.BackupDir, "backup_test.zip")
	f, err := os.Create(zipPath)
	require.NoError(t, err)
	_ = f.Close()

	// Create a non-zip file that should be ignored
	txtPath := filepath.Join(service.BackupDir, "readme.txt")
	_ = os.WriteFile(txtPath, []byte("not a backup"), 0o644)

	// Create a directory that should be ignored
	dirPath := filepath.Join(service.BackupDir, "subdir.zip")
	_ = os.MkdirAll(dirPath, 0o755)

	backups, err := service.ListBackups()
	require.NoError(t, err)
	// Should only list the zip file
	assert.Len(t, backups, 1)
	assert.Equal(t, "backup_test.zip", backups[0].Filename)
}

func TestRestoreBackup_PathTraversal_FirstCheck(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Test path traversal with filename containing path separator
	err := service.RestoreBackup("../../../etc/passwd")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid filename")
}

func TestRestoreBackup_PathTraversal_SecondCheck(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Test with a filename that passes the first check but could still
	// be problematic (this tests the second prefix check)
	err := service.RestoreBackup("../otherfile.zip")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid filename")
}

func TestDeleteBackup_PathTraversal_SecondCheck(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Test first check - filename with path separator
	err := service.DeleteBackup("sub/file.zip")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid filename")
}

func TestGetBackupPath_PathTraversal_SecondCheck(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Test first check - filename with path separator
	_, err := service.GetBackupPath("sub/file.zip")
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "invalid filename")
}

func TestUnzip_DirectoryCreation(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)
	_ = os.MkdirAll(service.DataDir, 0o755)

	// Create a zip with nested directory structure
	zipPath := filepath.Join(service.BackupDir, "nested.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	// Add a directory entry
	_, err = w.Create("subdir/")
	require.NoError(t, err)
	// Add a file in that directory
	f, err := w.Create("subdir/nested_file.txt")
	require.NoError(t, err)
	_, err = f.Write([]byte("nested content"))
	require.NoError(t, err)
	_ = w.Close()
	_ = zipFile.Close()

	// Restore the backup
	err = service.RestoreBackup("nested.zip")
	require.NoError(t, err)

	// Verify nested file was created
	content, err := os.ReadFile(filepath.Join(service.DataDir, "subdir", "nested_file.txt"))
	require.NoError(t, err)
	assert.Equal(t, "nested content", string(content))
}

func TestUnzip_OpenFileError(t *testing.T) {
	// Skip on root
	if os.Getuid() == 0 {
		t.Skip("Skipping test that requires non-root user")
	}

	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)
	_ = os.MkdirAll(service.DataDir, 0o755)

	// Create a valid zip
	zipPath := filepath.Join(service.BackupDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	f, err := w.Create("test.txt")
	require.NoError(t, err)
	_, err = f.Write([]byte("test content"))
	require.NoError(t, err)
	_ = w.Close()
	_ = zipFile.Close()

	// Make data dir read-only to cause OpenFile error
	_ = os.Chmod(service.DataDir, 0o444)
	defer func() { _ = os.Chmod(service.DataDir, 0o755) }()

	err = service.RestoreBackup("test.zip")
	assert.Error(t, err)
}

func TestUnzip_FileOpenInZipError(t *testing.T) {
	// This tests the error path when f.Open() fails
	// Hard to trigger naturally, but we can test normal zip restore works
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)
	_ = os.MkdirAll(service.DataDir, 0o755)

	// Create a valid zip with a file
	zipPath := filepath.Join(service.BackupDir, "valid.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	f, err := w.Create("test_file.txt")
	require.NoError(t, err)
	_, err = f.Write([]byte("file content"))
	require.NoError(t, err)
	_ = w.Close()
	_ = zipFile.Close()

	// Restore should work
	err = service.RestoreBackup("valid.zip")
	require.NoError(t, err)

	// Verify file was restored
	content, err := os.ReadFile(filepath.Join(service.DataDir, "test_file.txt"))
	require.NoError(t, err)
	assert.Equal(t, "file content", string(content))
}

func TestAddDirToZip_WalkError(t *testing.T) {
	tmpDir := t.TempDir()
	zipPath := filepath.Join(tmpDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)
	defer func() { _ = zipFile.Close() }()

	w := zip.NewWriter(zipFile)
	defer func() { _ = w.Close() }()

	service := &BackupService{}

	// Try to walk a non-existent directory
	err = service.addDirToZip(w, "/nonexistent/path", "base")
	assert.Error(t, err)
}

func TestAddDirToZip_SkipsDirectories(t *testing.T) {
	tmpDir := t.TempDir()

	// Create directory structure
	srcDir := filepath.Join(tmpDir, "src")
	_ = os.MkdirAll(filepath.Join(srcDir, "subdir"), 0o755)
	_ = os.WriteFile(filepath.Join(srcDir, "file1.txt"), []byte("content1"), 0o644)
	_ = os.WriteFile(filepath.Join(srcDir, "subdir", "file2.txt"), []byte("content2"), 0o644)

	zipPath := filepath.Join(tmpDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	service := &BackupService{}

	err = service.addDirToZip(w, srcDir, "backup")
	require.NoError(t, err)

	_ = w.Close()
	_ = zipFile.Close()

	// Verify zip contains expected files
	r, err := zip.OpenReader(zipPath)
	require.NoError(t, err)
	defer func() { _ = r.Close() }()

	fileNames := make([]string, 0)
	for _, f := range r.File {
		fileNames = append(fileNames, f.Name)
	}

	assert.Contains(t, fileNames, "backup/file1.txt")
	assert.Contains(t, fileNames, "backup/subdir/file2.txt")
}

func TestGetAvailableSpace_Success(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: tmpDir,
	}

	space, err := service.GetAvailableSpace()
	require.NoError(t, err)
	assert.Greater(t, space, int64(0))
}

func TestGetAvailableSpace_NonExistentDir(t *testing.T) {
	service := &BackupService{
		BackupDir: "/this/path/does/not/exist/anywhere",
	}

	_, err := service.GetAvailableSpace()
	assert.Error(t, err)
}

// Additional edge case tests for better coverage

func TestUnzip_CopyError(t *testing.T) {
	// Skip on root
	if os.Getuid() == 0 {
		t.Skip("Skipping test that requires non-root user")
	}

	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)
	_ = os.MkdirAll(service.DataDir, 0o755)

	// Create a valid zip
	zipPath := filepath.Join(service.BackupDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	f, err := w.Create("subdir/test.txt")
	require.NoError(t, err)
	_, err = f.Write([]byte("test content"))
	require.NoError(t, err)
	_ = w.Close()
	_ = zipFile.Close()

	// Create the subdir as read-only to cause copy error
	subDir := filepath.Join(service.DataDir, "subdir")
	_ = os.MkdirAll(subDir, 0o755)
	_ = os.Chmod(subDir, 0o444)
	defer func() { _ = os.Chmod(subDir, 0o755) }()

	// Restore should fail because we can't write to subdir
	err = service.RestoreBackup("test.zip")
	assert.Error(t, err)
}

func TestCreateBackup_ZipWriterCloseError(t *testing.T) {
	// This is hard to trigger directly, but we can verify the code path
	// by creating a valid backup and ensuring proper cleanup
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("test db content"), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop()

	// Create a backup successfully
	filename, err := service.CreateBackup()
	require.NoError(t, err)
	assert.NotEmpty(t, filename)

	// Verify the zip is valid by opening it
	backupPath := filepath.Join(service.BackupDir, filename)
	r, err := zip.OpenReader(backupPath)
	require.NoError(t, err)
	defer func() { _ = r.Close() }()

	// Verify it contains the database
	var foundDB bool
	for _, f := range r.File {
		if f.Name == "charon.db" {
			foundDB = true
			break
		}
	}
	assert.True(t, foundDB, "Backup should contain database file")
}

func TestAddToZip_CreateError(t *testing.T) {
	tmpDir := t.TempDir()
	zipPath := filepath.Join(tmpDir, "test.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)
	defer func() { _ = zipFile.Close() }()

	w := zip.NewWriter(zipFile)

	// Create a source file
	srcPath := filepath.Join(tmpDir, "source.txt")
	_ = os.WriteFile(srcPath, []byte("test content"), 0o644)

	service := &BackupService{}

	// Normal addToZip should work
	err = service.addToZip(w, srcPath, "dest.txt")
	require.NoError(t, err)

	// Close the writer to finalize
	_ = w.Close()

	// Try to add to closed writer - this should fail
	w2 := zip.NewWriter(zipFile)
	_ = service.addToZip(w2, srcPath, "dest2.txt")
	// This may or may not error depending on internal state
	// The main point is we're testing the code path
}

func TestListBackups_IgnoresNonZipFiles(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Create various files
	_ = os.WriteFile(filepath.Join(service.BackupDir, "backup.zip"), []byte(""), 0o644)
	_ = os.WriteFile(filepath.Join(service.BackupDir, "backup.tar.gz"), []byte(""), 0o644)
	_ = os.WriteFile(filepath.Join(service.BackupDir, "readme.txt"), []byte(""), 0o644)
	_ = os.WriteFile(filepath.Join(service.BackupDir, ".hidden.zip"), []byte(""), 0o644)

	backups, err := service.ListBackups()
	require.NoError(t, err)

	// Should only list files ending in .zip
	assert.Len(t, backups, 2) // backup.zip and .hidden.zip

	names := make([]string, 0)
	for _, b := range backups {
		names = append(names, b.Filename)
	}
	assert.Contains(t, names, "backup.zip")
	assert.Contains(t, names, ".hidden.zip")
}

func TestRestoreBackup_CreatesNestedDirectories(t *testing.T) {
	tmpDir := t.TempDir()
	service := &BackupService{
		DataDir:   filepath.Join(tmpDir, "data"),
		BackupDir: filepath.Join(tmpDir, "backups"),
	}
	_ = os.MkdirAll(service.BackupDir, 0o755)

	// Create a zip with deeply nested structure
	zipPath := filepath.Join(service.BackupDir, "nested.zip")
	zipFile, err := os.Create(zipPath)
	require.NoError(t, err)

	w := zip.NewWriter(zipFile)
	f, err := w.Create("a/b/c/d/deep_file.txt")
	require.NoError(t, err)
	_, err = f.Write([]byte("deep content"))
	require.NoError(t, err)
	_ = w.Close()
	_ = zipFile.Close()

	// DataDir doesn't exist yet
	err = service.RestoreBackup("nested.zip")
	require.NoError(t, err)

	// Verify deeply nested file was created
	content, err := os.ReadFile(filepath.Join(service.DataDir, "a", "b", "c", "d", "deep_file.txt"))
	require.NoError(t, err)
	assert.Equal(t, "deep content", string(content))
}

func TestBackupService_FullCycle(t *testing.T) {
	// Full integration test: create, list, restore, delete
	tmpDir := t.TempDir()
	dataDir := filepath.Join(tmpDir, "data")
	_ = os.MkdirAll(dataDir, 0o755)

	// Create database and caddy config
	dbPath := filepath.Join(dataDir, "charon.db")
	_ = os.WriteFile(dbPath, []byte("original db"), 0o644)

	caddyDir := filepath.Join(dataDir, "caddy")
	_ = os.MkdirAll(caddyDir, 0o755)
	_ = os.WriteFile(filepath.Join(caddyDir, "config.json"), []byte(`{"original": true}`), 0o644)

	cfg := &config.Config{DatabasePath: dbPath}
	service := NewBackupService(cfg)
	defer service.Stop()

	// Create backup
	filename, err := service.CreateBackup()
	require.NoError(t, err)

	// Modify files
	_ = os.WriteFile(dbPath, []byte("modified db"), 0o644)
	_ = os.WriteFile(filepath.Join(caddyDir, "config.json"), []byte(`{"modified": true}`), 0o644)

	// Verify modification
	content, _ := os.ReadFile(dbPath)
	assert.Equal(t, "modified db", string(content))

	// Restore backup
	err = service.RestoreBackup(filename)
	require.NoError(t, err)

	// Verify restoration
	content, _ = os.ReadFile(dbPath)
	assert.Equal(t, "original db", string(content))

	caddyContent, _ := os.ReadFile(filepath.Join(caddyDir, "config.json"))
	assert.Equal(t, `{"original": true}`, string(caddyContent))

	// List backups
	backups, err := service.ListBackups()
	require.NoError(t, err)
	assert.Len(t, backups, 1)

	// Get backup path
	path, err := service.GetBackupPath(filename)
	require.NoError(t, err)
	assert.FileExists(t, path)

	// Delete backup
	err = service.DeleteBackup(filename)
	require.NoError(t, err)

	// Verify deletion
	backups, err = service.ListBackups()
	require.NoError(t, err)
	assert.Empty(t, backups)
}