import threading
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import Any, Callable, Dict, Optional


@dataclass
class UploadResult:
    """Holds the result of a video upload."""
    direct_url: str
    embed_url: str
    provider_video_id: str
    raw_data: Dict[str, Any] = field(default_factory=dict)


class BaseVideoProvider(ABC):
    """Abstract base class for video streaming platform providers."""

    name: str = "base"

    @abstractmethod
    def validate_credentials(self, account: Dict[str, Any]) -> bool:
        """Validates if the account credentials or tokens are currently active."""
        pass

    @abstractmethod
    def upload(
        self,
        file_path: str,
        title: str,
        description: str = "",
        account: Optional[Dict[str, Any]] = None,
        progress_callback: Optional[Callable[[float], None]] = None,
        cancel_event: Optional[threading.Event] = None,
        **kwargs,
    ) -> UploadResult:
        """
        Uploads a video to the platform.
        Args:
            file_path: Path to the local video file.
            title: Title for the video.
            description: Description for the video.
            account: Account dict from database containing tokens/passwords/cookies.
            progress_callback: Optional callback accepting float percentage 0.0 - 100.0.
        Returns:
            UploadResult with direct_url, embed_url, and provider_video_id.
        """
        pass

    def wait_for_conversion(
        self,
        account: Optional[Dict[str, Any]],
        vcode: str,
        progress_callback: Optional[Callable[[float, str], None]] = None,
        cancel_event: Optional[threading.Event] = None,
        **kwargs,
    ) -> bool:
        """
        Waits for the provider to complete server-side video transcoding/conversion.
        Default implementation returns True immediately for providers that do not require wait.
        """
        return True