"""Sync result models.

Mirrors PlaylistSynchronizationResult and SyncCounts from the .NET codebase.
"""

from dataclasses import dataclass
from typing import Optional

from .enums import SyncError


@dataclass
class SyncCounts:
    added_tracks: int
    deleted_duplicates: int
    deleted_tracks: int
    reordered_tracks: int = 0


@dataclass
class PlaylistSynchronizationResult:
    synced_track_count: int = 0
    added_tracks: int = 0
    deleted_tracks: int = 0
    deleted_duplicates: int = 0
    reordered_tracks: int = 0
    error: Optional[SyncError] = None
    error_text: Optional[str] = None
    triggered_manually: bool = False
    made_changes: bool = False

    @classmethod
    def from_success(
        cls, counts: SyncCounts, source_track_count: int
    ) -> "PlaylistSynchronizationResult":
        made_changes = (
            counts.added_tracks > 0
            or counts.deleted_tracks > 0
            or counts.deleted_duplicates > 0
            or counts.reordered_tracks > 0
        )
        return cls(
            synced_track_count=source_track_count,
            added_tracks=counts.added_tracks,
            deleted_tracks=counts.deleted_tracks,
            deleted_duplicates=counts.deleted_duplicates,
            reordered_tracks=counts.reordered_tracks,
            made_changes=made_changes,
        )

    @classmethod
    def from_error(
        cls, error: SyncError, message: str
    ) -> "PlaylistSynchronizationResult":
        return cls(error=error, error_text=message)

    @classmethod
    def from_exception(cls, exc: Exception) -> "PlaylistSynchronizationResult":
        from .enums import SyncError as SE

        error_type = SE.VendorSpecific
        if hasattr(exc, "error"):
            error_type = exc.error
        return cls(error=error_type, error_text=str(exc))