"""
AWS S3 storage adaptor implementation.
"""

import os
from pathlib import Path

try:
    import boto3
    from botocore.exceptions import ClientError
    BOTO3_AVAILABLE = True
except ImportError:
    BOTO3_AVAILABLE = False

from .base_storage import BaseStorageAdaptor, StorageObject


class S3StorageAdaptor(BaseStorageAdaptor):
    """
    AWS S3 storage adaptor.

    Configuration:
        bucket: S3 bucket name (required)
        region: AWS region (optional, default: us-east-1)
        aws_access_key_id: AWS access key (optional, uses env/credentials)
        aws_secret_access_key: AWS secret key (optional, uses env/credentials)
        endpoint_url: Custom endpoint URL (optional, for S3-compatible services)

    Environment Variables:
        AWS_ACCESS_KEY_ID: AWS access key
        AWS_SECRET_ACCESS_KEY: AWS secret key
        AWS_DEFAULT_REGION: AWS region

    Examples:
        # Using environment variables
        adaptor = S3StorageAdaptor(bucket='my-bucket')

        # With explicit credentials
        adaptor = S3StorageAdaptor(
            bucket='my-bucket',
            region='us-west-2',
            aws_access_key_id='AKIAIOSFODNN7EXAMPLE',
            aws_secret_access_key='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
        )

        # S3-compatible service (MinIO, DigitalOcean Spaces)
        adaptor = S3StorageAdaptor(
            bucket='my-bucket',
            endpoint_url='https://nyc3.digitaloceanspaces.com',
            aws_access_key_id='...',
            aws_secret_access_key='...'
        )
    """

    def __init__(self, **kwargs):
        """
        Initialize S3 storage adaptor.

        Args:
            bucket: S3 bucket name (required)
            **kwargs: Additional S3 configuration
        """
        super().__init__(**kwargs)

        if not BOTO3_AVAILABLE:
            raise ImportError(
                "boto3 is required for S3 storage. "
                "Install with: pip install boto3"
            )

        if 'bucket' not in kwargs:
            raise ValueError("bucket parameter is required for S3 storage")

        self.bucket = kwargs['bucket']
        self.region = kwargs.get('region', os.getenv('AWS_DEFAULT_REGION', 'us-east-1'))

        # Initialize S3 client
        client_kwargs = {
            'region_name': self.region,
        }

        if 'endpoint_url' in kwargs:
            client_kwargs['endpoint_url'] = kwargs['endpoint_url']

        if 'aws_access_key_id' in kwargs:
            client_kwargs['aws_access_key_id'] = kwargs['aws_access_key_id']

        if 'aws_secret_access_key' in kwargs:
            client_kwargs['aws_secret_access_key'] = kwargs['aws_secret_access_key']

        self.s3_client = boto3.client('s3', **client_kwargs)
        self.s3_resource = boto3.resource('s3', **client_kwargs)

    def upload_file(
        self, local_path: str, remote_path: str, metadata: dict[str, str] | None = None
    ) -> str:
        """Upload file to S3."""
        local_file = Path(local_path)
        if not local_file.exists():
            raise FileNotFoundError(f"Local file not found: {local_path}")

        extra_args = {}
        if metadata:
            extra_args['Metadata'] = metadata

        try:
            self.s3_client.upload_file(
                str(local_file),
                self.bucket,
                remote_path,
                ExtraArgs=extra_args if extra_args else None
            )
            return f"s3://{self.bucket}/{remote_path}"
        except ClientError as e:
            raise Exception(f"S3 upload failed: {e}") from e

    def download_file(self, remote_path: str, local_path: str) -> None:
        """Download file from S3."""
        local_file = Path(local_path)
        local_file.parent.mkdir(parents=True, exist_ok=True)

        try:
            self.s3_client.download_file(
                self.bucket,
                remote_path,
                str(local_file)
            )
        except ClientError as e:
            if e.response['Error']['Code'] == '404':
                raise FileNotFoundError(f"Remote file not found: {remote_path}") from e
            raise Exception(f"S3 download failed: {e}") from e

    def delete_file(self, remote_path: str) -> None:
        """Delete file from S3."""
        try:
            self.s3_client.delete_object(
                Bucket=self.bucket,
                Key=remote_path
            )
        except ClientError as e:
            raise Exception(f"S3 deletion failed: {e}") from e

    def list_files(
        self, prefix: str = "", max_results: int = 1000
    ) -> list[StorageObject]:
        """List files in S3 bucket."""
        try:
            paginator = self.s3_client.get_paginator('list_objects_v2')
            page_iterator = paginator.paginate(
                Bucket=self.bucket,
                Prefix=prefix,
                PaginationConfig={'MaxItems': max_results}
            )

            files = []
            for page in page_iterator:
                if 'Contents' not in page:
                    continue

                for obj in page['Contents']:
                    files.append(StorageObject(
                        key=obj['Key'],
                        size=obj['Size'],
                        last_modified=obj['LastModified'].isoformat(),
                        etag=obj.get('ETag', '').strip('"')
                    ))

            return files
        except ClientError as e:
            raise Exception(f"S3 listing failed: {e}") from e

    def file_exists(self, remote_path: str) -> bool:
        """Check if file exists in S3."""
        try:
            self.s3_client.head_object(
                Bucket=self.bucket,
                Key=remote_path
            )
            return True
        except ClientError as e:
            if e.response['Error']['Code'] == '404':
                return False
            raise Exception(f"S3 head_object failed: {e}") from e

    def get_file_url(self, remote_path: str, expires_in: int = 3600) -> str:
        """Generate presigned URL for S3 object."""
        try:
            url = self.s3_client.generate_presigned_url(
                'get_object',
                Params={
                    'Bucket': self.bucket,
                    'Key': remote_path
                },
                ExpiresIn=expires_in
            )
            return url
        except ClientError as e:
            raise Exception(f"S3 presigned URL generation failed: {e}") from e

    def copy_file(self, source_path: str, dest_path: str) -> None:
        """Copy file within S3 bucket (server-side copy)."""
        try:
            copy_source = {
                'Bucket': self.bucket,
                'Key': source_path
            }
            self.s3_client.copy_object(
                CopySource=copy_source,
                Bucket=self.bucket,
                Key=dest_path
            )
        except ClientError as e:
            if e.response['Error']['Code'] == '404':
                raise FileNotFoundError(f"Source file not found: {source_path}") from e
            raise Exception(f"S3 copy failed: {e}") from e