package storage

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestNewStorage(t *testing.T) {
	t.Run("Local Storage", func(t *testing.T) {
		config := Config{
			Backend: "local",
			Local: LocalConfig{
				RootDir: t.TempDir(),
			},
		}
		
		storage, err := NewStorage(config)
		assert.NoError(t, err)
		assert.IsType(t, &LocalStorage{}, storage)
	})
	
	t.Run("Default to Local Storage", func(t *testing.T) {
		config := Config{
			// No backend specified
			Local: LocalConfig{
				RootDir: t.TempDir(),
			},
		}
		
		storage, err := NewStorage(config)
		assert.NoError(t, err)
		assert.IsType(t, &LocalStorage{}, storage)
	})
	
	t.Run("S3 Storage", func(t *testing.T) {
		config := Config{
			Backend: "s3",
			S3: S3Config{
				Region: "us-east-1",
				Bucket: "test-bucket",
			},
		}
		
		// This might succeed if AWS credentials are available via IAM roles or env vars
		// Let's just check that we get an S3Storage instance or an error
		storage, err := NewStorage(config)
		if err != nil {
			// If it fails, that's expected in test environments without AWS access
			assert.Nil(t, storage)
		} else {
			// If it succeeds, we should get an S3Storage instance
			assert.IsType(t, &S3Storage{}, storage)
		}
	})
	
	t.Run("B2 Storage", func(t *testing.T) {
		config := Config{
			Backend: "b2",
			B2: B2Config{
				AccountID:      "test-account",
				ApplicationKey: "test-key",
				Bucket:         "test-bucket",
			},
		}
		
		// This will fail because we don't have real B2 credentials
		storage, err := NewStorage(config)
		assert.Error(t, err) // Expected to fail without credentials
		assert.Nil(t, storage)
	})
	
	t.Run("Unsupported Backend", func(t *testing.T) {
		config := Config{
			Backend: "unsupported",
		}
		
		storage, err := NewStorage(config)
		assert.Error(t, err)
		assert.IsType(t, &UnsupportedBackendError{}, err)
		assert.Nil(t, storage)
		assert.Contains(t, err.Error(), "unsupported")
	})
}

func TestStorageErrors(t *testing.T) {
	t.Run("UnsupportedBackendError", func(t *testing.T) {
		err := &UnsupportedBackendError{Backend: "ftp"}
		assert.Equal(t, "unsupported storage backend: ftp", err.Error())
	})
	
	t.Run("FileNotFoundError", func(t *testing.T) {
		err := &FileNotFoundError{Path: "missing.txt"}
		assert.Equal(t, "file not found: missing.txt", err.Error())
	})
	
	t.Run("InvalidPathError", func(t *testing.T) {
		err := &InvalidPathError{Path: "../../../etc/passwd"}
		assert.Equal(t, "invalid path: ../../../etc/passwd", err.Error())
	})
}