import faker
import pytest
from fansifter_common.auth.account import Account

from ows_text_campaigns.assets.models import Asset
from ows_text_campaigns.audiences.enums import AudienceTarget, FanDataListType
from ows_text_campaigns.audiences.models import (
    Audience,
    AudienceFanDataList,
)
from ows_text_campaigns.campaigns.enums import CampaignStatus, ShorteningMethod
from ows_text_campaigns.campaigns.exceptions import (
    CampaignUniqueNameError,
)
from ows_text_campaigns.campaigns.handlers import (
    DuplicateCampaignHandler,
    DuplicateCampaignRequest,
)
from ows_text_campaigns.campaigns.models import Campaign
from ows_text_campaigns.campaigns.types import ShortenedUrl
from ows_text_campaigns.campaigns.utils import create_short_link_tag

from tests.unit.types import BuildModel, CreateModel, CreatePgModel


class TestDuplicateCampaignHandler:
    @pytest.mark.db
    def test_duplicate_campaign(
        self,
        handler: DuplicateCampaignHandler,
        build_model: BuildModel,
        create_model: CreateModel,
        create_pg_model: CreatePgModel,
        faker: faker.Faker,
        account: Account,
        identity_id: str,
    ) -> None:
        global_participant_id = faker.uuid4()

        shortened_url = build_model(ShortenedUrl, method=ShorteningMethod.STANDARD)

        audience = create_pg_model(
            Audience,
            target=AudienceTarget.TEXT,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
            fandata_lists=[
                AudienceFanDataList(
                    list_id=global_participant_id,
                    type=FanDataListType.ARTIST,
                )
            ],
        )

        asset = create_model(Asset)

        campaign = create_model(
            Campaign,
            audience_id=audience.id,
            status=CampaignStatus.DRAFT,
            vendor_id=account.vendor_id,
            subaccount_id=account.subaccount_id,
            global_participant_id=global_participant_id,
            content=create_short_link_tag(shortened_url),
            assets=[asset],
        )
        new_name = f"{campaign.name} (Copy)"

        campaign_copy = handler.handle(
            DuplicateCampaignRequest(
                identity_id=identity_id,
                campaign_id=campaign.id,
                name=new_name,
            )
        )

        assert campaign_copy.name == new_name
        assert campaign_copy.vendor_id == campaign.vendor_id
        assert campaign_copy.subaccount_id == campaign.subaccount_id
        assert campaign_copy.global_participant_id == global_participant_id
        assert campaign_copy.status == CampaignStatus.DRAFT
        assert campaign_copy.created_by == identity_id
        assert campaign_copy.updated_by == identity_id
        assert campaign_copy.audience_id == audience.id
        assert campaign_copy.recipients_count == audience.fan_count

        # The shortened URL should be replaced in the duplicated campaign content
        assert campaign_copy.content == (
            f'<a href="{shortened_url.url}">{shortened_url.url}</a>'
        )

        asset_copy = campaign_copy.assets[0]

        assert asset_copy.id != asset.id
        assert asset_copy.object_id == campaign_copy.id
        assert asset_copy.object_type == asset.object_type
        assert asset_copy.original_filename == asset.original_filename
        assert asset_copy.key == asset.key
        assert asset_copy.content_type == asset.content_type
        assert asset_copy.extension == asset.extension
        assert asset_copy.file_size == asset.file_size
        assert asset_copy.image_width == asset.image_width
        assert asset_copy.image_height == asset.image_height
        assert asset_copy.created_by == identity_id

    @pytest.mark.db
    def test_duplicate_campaign_unique_name(
        self,
        handler: DuplicateCampaignHandler,
        create_model: CreateModel,
        identity_id: str,
    ) -> None:
        campaign = create_model(Campaign, status=CampaignStatus.DRAFT)

        with pytest.raises(CampaignUniqueNameError):
            handler.handle(
                DuplicateCampaignRequest(
                    identity_id=identity_id,
                    campaign_id=campaign.id,
                    name=campaign.name,
                )
            )