from dataclasses import dataclass

from anydi import singleton
from fansifter_common.auth.requests import AuthAccountRequest
from fansifter_common.auth.services import AuthService
from fansifter_common.auth.types import Permission
from fansifter_common.auth.validators import AccountValidator

from ows_text_campaigns.adapters.db.decorators import transactional
from ows_text_campaigns.artist.services import ArtistSettingsService
from ows_text_campaigns.campaigns.enums import MessageChannel
from ows_text_campaigns.campaigns.models import Campaign
from ows_text_campaigns.campaigns.repositories import CampaignRepository
from ows_text_campaigns.campaigns.validators import CampaignValidator
from ows_text_campaigns.rosters.services import GlobalFanDataAccessService


@dataclass
class CreateCampaignRequest(AuthAccountRequest):
    name: str
    global_participant_id: str
    audience_id: str | None
    channel: MessageChannel = MessageChannel.SMS


@singleton
class CreateCampaignHandler:
    permission = Permission("text_campaign", "create")

    def __init__(
        self,
        auth_service: AuthService,
        campaign_repository: CampaignRepository,
        campaign_validator: CampaignValidator,
        artist_settings_service: ArtistSettingsService,
        account_validator: AccountValidator,
        global_fandata_access_service: GlobalFanDataAccessService,
    ) -> None:
        self.auth_service = auth_service
        self.campaign_repository = campaign_repository
        self.campaign_validator = campaign_validator
        self.artist_settings_service = artist_settings_service
        self.account_validator = account_validator
        self.global_fandata_access_service = global_fandata_access_service

    @transactional
    def handle(self, request: CreateCampaignRequest) -> Campaign:
        self.auth_service.check_account_resource(
            request.identity_id,
            account=request.account,
            permission=self.permission,
        )

        # Validate account
        self.account_validator.validate_account(request.account, allow_subaccount=False)

        # Validate text campaign name
        self.campaign_validator.validate_name(request.name, account=request.account)

        if request.audience_id:
            audience = self.campaign_validator.validate_audience_id(
                audience_id=request.audience_id,
                account=request.account,
            )
        else:
            audience = None

        # Validate global participant ID
        self.artist_settings_service.validate_global_participant_id(
            request.global_participant_id
        )

        # Validate main rep only artist if global fandata list is enabled for vendor
        global_fandata_list_enabled = (
            self.global_fandata_access_service.is_enabled_for_vendor(request.vendor_id)
        )
        if global_fandata_list_enabled:
            self.campaign_validator.validate_main_rep_only_artist(
                global_participant_id=request.global_participant_id,
                account=request.account,
            )

        # Get artist configured settings
        artist_settings = self.artist_settings_service.get_configured_settings(
            request.global_participant_id
        )

        campaign = Campaign(
            name=request.name,
            vendor_id=request.vendor_id,
            subaccount_id=request.subaccount_id,
            global_participant_id=artist_settings.global_participant_id,
            channel=request.channel,
            created_by=request.identity_id,
            updated_by=request.identity_id,
        )

        # Set audience
        campaign.audience = audience

        self.campaign_repository.save(campaign)
        return campaign