"""
Tests for cloud storage adaptors.
"""

import os
import sys
import pytest
import tempfile
from pathlib import Path
from unittest.mock import Mock, patch

from skill_seekers.cli.storage import (
    get_storage_adaptor,
    BaseStorageAdaptor,
    S3StorageAdaptor,
    GCSStorageAdaptor,
    AzureStorageAdaptor,
    StorageObject,
)

# Check if cloud storage dependencies are available
try:
    import boto3  # noqa: F401
    BOTO3_AVAILABLE = True
except ImportError:
    BOTO3_AVAILABLE = False

try:
    from google.cloud import storage  # noqa: F401
    GCS_AVAILABLE = True
except ImportError:
    GCS_AVAILABLE = False

try:
    from azure.storage.blob import BlobServiceClient  # noqa: F401
    AZURE_AVAILABLE = True
except ImportError:
    AZURE_AVAILABLE = False


# ========================================
# Factory Tests
# ========================================

def test_get_storage_adaptor_s3():
    """Test S3 adaptor factory."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    with patch('skill_seekers.cli.storage.s3_storage.boto3'):
        adaptor = get_storage_adaptor('s3', bucket='test-bucket')
        assert isinstance(adaptor, S3StorageAdaptor)


def test_get_storage_adaptor_gcs():
    """Test GCS adaptor factory."""
    if not GCS_AVAILABLE:
        pytest.skip("google-cloud-storage not installed")
    with patch('skill_seekers.cli.storage.gcs_storage.storage'):
        adaptor = get_storage_adaptor('gcs', bucket='test-bucket')
        assert isinstance(adaptor, GCSStorageAdaptor)


def test_get_storage_adaptor_azure():
    """Test Azure adaptor factory."""
    if not AZURE_AVAILABLE:
        pytest.skip("azure-storage-blob not installed")
    with patch('skill_seekers.cli.storage.azure_storage.BlobServiceClient'):
        adaptor = get_storage_adaptor(
            'azure',
            container='test-container',
            connection_string='DefaultEndpointsProtocol=https;AccountName=test;AccountKey=key'
        )
        assert isinstance(adaptor, AzureStorageAdaptor)


def test_get_storage_adaptor_invalid_provider():
    """Test invalid provider raises error."""
    with pytest.raises(ValueError, match="Unsupported storage provider"):
        get_storage_adaptor('invalid', bucket='test')


# ========================================
# S3 Storage Tests
# ========================================

def test_s3_upload_file():
    """Test S3 file upload."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        # Create temporary file
        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
            tmp_file.write(b'test content')
            tmp_path = tmp_file.name

        try:
            # Test upload
            result = adaptor.upload_file(tmp_path, 'test.txt')

            assert result == 's3://test-bucket/test.txt'
            mock_client.upload_file.assert_called_once()
        finally:
            Path(tmp_path).unlink()


def test_s3_download_file():
    """Test S3 file download."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        with tempfile.TemporaryDirectory() as tmp_dir:
            local_path = os.path.join(tmp_dir, 'downloaded.txt')

            # Test download
            adaptor.download_file('test.txt', local_path)

            mock_client.download_file.assert_called_once_with(
                'test-bucket', 'test.txt', local_path
            )


def test_s3_list_files():
    """Test S3 file listing."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_paginator = Mock()
        mock_page_iterator = [
            {
                'Contents': [
                    {
                        'Key': 'file1.txt',
                        'Size': 100,
                        'LastModified': Mock(isoformat=lambda: '2024-01-01T00:00:00'),
                        'ETag': '"abc123"'
                    }
                ]
            }
        ]

        mock_paginator.paginate.return_value = mock_page_iterator
        mock_client.get_paginator.return_value = mock_paginator
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        # Test list
        files = adaptor.list_files('prefix/')

        assert len(files) == 1
        assert files[0].key == 'file1.txt'
        assert files[0].size == 100
        assert files[0].etag == 'abc123'


def test_s3_file_exists():
    """Test S3 file existence check."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_client.head_object.return_value = {}
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        # Test exists
        assert adaptor.file_exists('test.txt') is True


def test_s3_get_file_url():
    """Test S3 presigned URL generation."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_client.generate_presigned_url.return_value = 'https://s3.amazonaws.com/signed-url'
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        # Test URL generation
        url = adaptor.get_file_url('test.txt', expires_in=7200)

        assert url == 'https://s3.amazonaws.com/signed-url'
        mock_client.generate_presigned_url.assert_called_once()


# ========================================
# GCS Storage Tests
# ========================================

def test_gcs_upload_file():
    """Test GCS file upload."""
    if not GCS_AVAILABLE:
        pytest.skip("google-cloud-storage not installed")
    
    with patch('skill_seekers.cli.storage.gcs_storage.storage') as mock_storage:
        # Setup mocks
        mock_client = Mock()
        mock_bucket = Mock()
        mock_blob = Mock()

        mock_client.bucket.return_value = mock_bucket
        mock_bucket.blob.return_value = mock_blob
        mock_storage.Client.return_value = mock_client

        adaptor = GCSStorageAdaptor(bucket='test-bucket')

        # Create temporary file
        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
            tmp_file.write(b'test content')
            tmp_path = tmp_file.name

        try:
            # Test upload
            result = adaptor.upload_file(tmp_path, 'test.txt')

            assert result == 'gs://test-bucket/test.txt'
            mock_blob.upload_from_filename.assert_called_once()
        finally:
            Path(tmp_path).unlink()


def test_gcs_download_file():
    """Test GCS file download."""
    if not GCS_AVAILABLE:
        pytest.skip("google-cloud-storage not installed")
    
    with patch('skill_seekers.cli.storage.gcs_storage.storage') as mock_storage:
        # Setup mocks
        mock_client = Mock()
        mock_bucket = Mock()
        mock_blob = Mock()

        mock_client.bucket.return_value = mock_bucket
        mock_bucket.blob.return_value = mock_blob
        mock_storage.Client.return_value = mock_client

        adaptor = GCSStorageAdaptor(bucket='test-bucket')

        with tempfile.TemporaryDirectory() as tmp_dir:
            local_path = os.path.join(tmp_dir, 'downloaded.txt')

            # Test download
            adaptor.download_file('test.txt', local_path)

            mock_blob.download_to_filename.assert_called_once()


def test_gcs_list_files():
    """Test GCS file listing."""
    if not GCS_AVAILABLE:
        pytest.skip("google-cloud-storage not installed")
    
    with patch('skill_seekers.cli.storage.gcs_storage.storage') as mock_storage:
        # Setup mocks
        mock_client = Mock()
        mock_blob = Mock()
        mock_blob.name = 'file1.txt'
        mock_blob.size = 100
        mock_blob.updated = Mock(isoformat=lambda: '2024-01-01T00:00:00')
        mock_blob.etag = 'abc123'
        mock_blob.metadata = {}

        mock_client.list_blobs.return_value = [mock_blob]
        mock_storage.Client.return_value = mock_client
        mock_client.bucket.return_value = Mock()

        adaptor = GCSStorageAdaptor(bucket='test-bucket')

        # Test list
        files = adaptor.list_files('prefix/')

        assert len(files) == 1
        assert files[0].key == 'file1.txt'
        assert files[0].size == 100


# ========================================
# Azure Storage Tests
# ========================================

def test_azure_upload_file():
    """Test Azure file upload."""
    if not AZURE_AVAILABLE:
        pytest.skip("azure-storage-blob not installed")
    
    with patch('skill_seekers.cli.storage.azure_storage.BlobServiceClient') as mock_blob_service:
        # Setup mocks
        mock_service_client = Mock()
        mock_container_client = Mock()
        mock_blob_client = Mock()

        mock_service_client.get_container_client.return_value = mock_container_client
        mock_container_client.get_blob_client.return_value = mock_blob_client
        mock_blob_service.from_connection_string.return_value = mock_service_client

        connection_string = 'DefaultEndpointsProtocol=https;AccountName=test;AccountKey=key'
        adaptor = AzureStorageAdaptor(container='test-container', connection_string=connection_string)

        # Create temporary file
        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
            tmp_file.write(b'test content')
            tmp_path = tmp_file.name

        try:
            # Test upload
            result = adaptor.upload_file(tmp_path, 'test.txt')

            assert 'test.blob.core.windows.net' in result
            mock_blob_client.upload_blob.assert_called_once()
        finally:
            Path(tmp_path).unlink()


def test_azure_download_file():
    """Test Azure file download."""
    if not AZURE_AVAILABLE:
        pytest.skip("azure-storage-blob not installed")
    
    with patch('skill_seekers.cli.storage.azure_storage.BlobServiceClient') as mock_blob_service:
        # Setup mocks
        mock_service_client = Mock()
        mock_container_client = Mock()
        mock_blob_client = Mock()
        mock_download_stream = Mock()
        mock_download_stream.readall.return_value = b'test content'

        mock_service_client.get_container_client.return_value = mock_container_client
        mock_container_client.get_blob_client.return_value = mock_blob_client
        mock_blob_client.download_blob.return_value = mock_download_stream
        mock_blob_service.from_connection_string.return_value = mock_service_client

        connection_string = 'DefaultEndpointsProtocol=https;AccountName=test;AccountKey=key'
        adaptor = AzureStorageAdaptor(container='test-container', connection_string=connection_string)

        with tempfile.TemporaryDirectory() as tmp_dir:
            local_path = os.path.join(tmp_dir, 'downloaded.txt')

            # Test download
            adaptor.download_file('test.txt', local_path)

            assert Path(local_path).exists()
            assert Path(local_path).read_bytes() == b'test content'


def test_azure_list_files():
    """Test Azure file listing."""
    if not AZURE_AVAILABLE:
        pytest.skip("azure-storage-blob not installed")
    
    with patch('skill_seekers.cli.storage.azure_storage.BlobServiceClient') as mock_blob_service:
        # Setup mocks
        mock_service_client = Mock()
        mock_container_client = Mock()
        mock_blob = Mock()
        mock_blob.name = 'file1.txt'
        mock_blob.size = 100
        mock_blob.last_modified = Mock(isoformat=lambda: '2024-01-01T00:00:00')
        mock_blob.etag = 'abc123'
        mock_blob.metadata = {}

        mock_container_client.list_blobs.return_value = [mock_blob]
        mock_service_client.get_container_client.return_value = mock_container_client
        mock_blob_service.from_connection_string.return_value = mock_service_client

        connection_string = 'DefaultEndpointsProtocol=https;AccountName=test;AccountKey=key'
        adaptor = AzureStorageAdaptor(container='test-container', connection_string=connection_string)

        # Test list
        files = adaptor.list_files('prefix/')

        assert len(files) == 1
        assert files[0].key == 'file1.txt'
        assert files[0].size == 100


# ========================================
# Base Adaptor Tests
# ========================================

def test_storage_object():
    """Test StorageObject dataclass."""
    obj = StorageObject(
        key='test.txt',
        size=100,
        last_modified='2024-01-01T00:00:00',
        etag='abc123',
        metadata={'key': 'value'}
    )

    assert obj.key == 'test.txt'
    assert obj.size == 100
    assert obj.metadata == {'key': 'value'}


def test_base_adaptor_abstract():
    """Test that BaseStorageAdaptor cannot be instantiated."""
    with pytest.raises(TypeError):
        BaseStorageAdaptor(bucket='test')


# ========================================
# Integration-style Tests
# ========================================

def test_upload_directory():
    """Test directory upload."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        # Create temporary directory with files
        with tempfile.TemporaryDirectory() as tmp_dir:
            (Path(tmp_dir) / 'file1.txt').write_text('content1')
            (Path(tmp_dir) / 'file2.txt').write_text('content2')
            (Path(tmp_dir) / 'subdir').mkdir()
            (Path(tmp_dir) / 'subdir' / 'file3.txt').write_text('content3')

            # Test upload directory
            uploaded_files = adaptor.upload_directory(tmp_dir, 'skills/')

            assert len(uploaded_files) == 3
            assert mock_client.upload_file.call_count == 3


def test_download_directory():
    """Test directory download."""
    if not BOTO3_AVAILABLE:
        pytest.skip("boto3 not installed")
    
    with patch('skill_seekers.cli.storage.s3_storage.boto3') as mock_boto3:
        # Setup mocks
        mock_client = Mock()
        mock_paginator = Mock()
        mock_page_iterator = [
            {
                'Contents': [
                    {
                        'Key': 'skills/file1.txt',
                        'Size': 100,
                        'LastModified': Mock(isoformat=lambda: '2024-01-01T00:00:00'),
                        'ETag': '"abc"'
                    },
                    {
                        'Key': 'skills/file2.txt',
                        'Size': 200,
                        'LastModified': Mock(isoformat=lambda: '2024-01-01T00:00:00'),
                        'ETag': '"def"'
                    }
                ]
            }
        ]

        mock_paginator.paginate.return_value = mock_page_iterator
        mock_client.get_paginator.return_value = mock_paginator
        mock_boto3.client.return_value = mock_client
        mock_boto3.resource.return_value = Mock()

        adaptor = S3StorageAdaptor(bucket='test-bucket')

        with tempfile.TemporaryDirectory() as tmp_dir:
            # Test download directory
            downloaded_files = adaptor.download_directory('skills/', tmp_dir)

            assert len(downloaded_files) == 2
            assert mock_client.download_file.call_count == 2


def test_missing_dependencies():
    """Test graceful handling of missing dependencies."""
    # This test verifies that the modules can be imported even without optional deps
    # The actual import checks are done at class initialization time
    assert S3StorageAdaptor is not None
    assert GCSStorageAdaptor is not None
    assert AzureStorageAdaptor is not None