"""
File handling utilities for CreativeX API Integration
"""

import mimetypes
import os
from pathlib import Path
from typing import Optional


class FileHandler:
    """Utilities for file operations and validation"""

    # Supported file formats
    SUPPORTED_VIDEO_FORMATS = ['.mp4', '.mov']
    SUPPORTED_IMAGE_FORMATS = ['.jpg', '.jpeg', '.png']

    @staticmethod
    def get_file_extension(file_path: str) -> str:
        """
        Get file extension in lowercase including dot

        Args:
            file_path: Path to file

        Returns:
            str: Lowercase extension including dot (e.g., '.mp4')
        """
        return Path(file_path).suffix.lower()

    @staticmethod
    def get_file_size_mb(file_path: str) -> float:
        """
        Get file size in megabytes

        Args:
            file_path: Path to file

        Returns:
            float: File size in MB
        """
        size_bytes = os.path.getsize(file_path)
        return size_bytes / (1024 * 1024)

    @staticmethod
    def is_video_file(file_path: str) -> bool:
        """
        Check if file is a supported video format

        Args:
            file_path: Path to file

        Returns:
            bool: True if video file
        """
        ext = FileHandler.get_file_extension(file_path)
        return ext in FileHandler.SUPPORTED_VIDEO_FORMATS

    @staticmethod
    def is_image_file(file_path: str) -> bool:
        """
        Check if file is a supported image format

        Args:
            file_path: Path to file

        Returns:
            bool: True if image file
        """
        ext = FileHandler.get_file_extension(file_path)
        return ext in FileHandler.SUPPORTED_IMAGE_FORMATS

    @staticmethod
    def is_supported_format(file_path: str) -> bool:
        """
        Check if file format is supported

        Args:
            file_path: Path to file

        Returns:
            bool: True if supported format
        """
        return (FileHandler.is_video_file(file_path) or
                FileHandler.is_image_file(file_path))

    @staticmethod
    def get_content_type(file_path: str) -> Optional[str]:
        """
        Get MIME content type for file

        Args:
            file_path: Path to file

        Returns:
            str: MIME type (e.g., 'video/mp4', 'image/jpeg')
            None: If type cannot be determined
        """
        # Try to guess from extension
        content_type, _ = mimetypes.guess_type(file_path)

        if content_type:
            return content_type

        # Fallback based on extension
        ext = FileHandler.get_file_extension(file_path)
        content_type_map = {
            '.mp4': 'video/mp4',
            '.mov': 'video/quicktime',
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
        }

        return content_type_map.get(ext, 'application/octet-stream')

    @staticmethod
    def file_exists(file_path: str) -> bool:
        """
        Check if file exists

        Args:
            file_path: Path to file

        Returns:
            bool: True if file exists
        """
        return Path(file_path).exists()

    @staticmethod
    def is_readable(file_path: str) -> bool:
        """
        Check if file is readable

        Args:
            file_path: Path to file

        Returns:
            bool: True if file is readable
        """
        try:
            return os.access(file_path, os.R_OK)
        except Exception:
            return False

    @staticmethod
    def get_filename(file_path: str) -> str:
        """
        Get filename from path (with extension)

        Args:
            file_path: Path to file

        Returns:
            str: Filename with extension
        """
        return Path(file_path).name

    @staticmethod
    def get_absolute_path(file_path: str) -> str:
        """
        Get absolute path of file

        Args:
            file_path: Path to file

        Returns:
            str: Absolute path
        """
        return str(Path(file_path).absolute())