import faker
import pytest

from email_campaigns.automated.enums import AutomatedEmailType
from email_campaigns.automated.models import (
    AutomatedEmail,
    AutomatedEmailTrigger,
    SourceCampaign,
)
from email_campaigns.automated.repositories import SourceCampaignRepository
from email_campaigns.automated.types import SourceCampaignCriteria

from tests.unit.types import CreateModel


class TestSourceCampaignRepository:
    @pytest.mark.db
    def test_find_by_source_and_campaign_id(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
    ) -> None:
        source_campaign = create_model(
            SourceCampaign,
            source="smf",
            campaign_id="campaign-123",
        )
        create_model(
            SourceCampaign,
            source="smf",
            campaign_id="campaign-other",
        )
        create_model(
            SourceCampaign,
            source="wyng",
            campaign_id="campaign-123",
        )

        result = repository.find_by_source_and_campaign_id("SMF", "campaign-123")

        assert result is not None
        assert result.id == source_campaign.id

    @pytest.mark.db
    def test_find_by_source_and_campaign_id_not_found(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
    ) -> None:
        create_model(
            SourceCampaign,
            source="smf",
            campaign_id="campaign-123",
        )

        result = repository.find_by_source_and_campaign_id("smf", "nonexistent")

        assert result is None

    @pytest.mark.db
    def test_find_by_criteria_with_search(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
    ) -> None:
        source_campaign1 = create_model(SourceCampaign, name="Test Campaign One")
        source_campaign2 = create_model(SourceCampaign, name="Test Campaign Two")
        create_model(SourceCampaign, name="Another Campaign")

        result = repository.find_by_criteria(
            criteria=SourceCampaignCriteria(
                search="Test",
                vendor_ids=None,
                subaccount_ids=None,
                current_automated_email_id=None,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=50,
            offset=0,
        )

        assert len(result) == 2
        assert result[0].id == source_campaign1.id
        assert result[1].id == source_campaign2.id

    @pytest.mark.db
    def test_count_by_criteria_with_search(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
    ) -> None:
        create_model(SourceCampaign, name="Test Campaign One")
        create_model(SourceCampaign, name="Test Campaign Two")
        create_model(SourceCampaign, name="Another Campaign")

        count = repository.count_by_criteria(
            SourceCampaignCriteria(
                search="Test",
                vendor_ids=None,
                subaccount_ids=None,
                current_automated_email_id=None,
                status=None,
                email_type=None,
            )
        )

        assert count == 2

    @pytest.mark.db
    def test_find_by_criteria_without_search(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
    ) -> None:
        create_model(SourceCampaign, name="Campaign One")
        create_model(SourceCampaign, name="Campaign Two")
        create_model(SourceCampaign, name="Campaign Three")

        result = repository.find_by_criteria(
            criteria=SourceCampaignCriteria(
                search=None,
                vendor_ids=None,
                subaccount_ids=None,
                current_automated_email_id=None,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=50,
            offset=0,
        )

        assert len(result) == 3

    @pytest.mark.db
    def test_find_by_criteria_with_status(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        source_campaign_1 = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            status="PUBLISHED",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            status="DRAFT",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            status="INACTIVE",
        )

        criteria = SourceCampaignCriteria(
            search=None,
            vendor_ids={vendor_id},
            subaccount_ids={subaccount_id},
            current_automated_email_id=None,
            status="PUBLISHED",
            email_type=None,
        )
        result = repository.find_by_criteria(
            criteria, order_by=["name.asc"], limit=10, offset=0
        )

        assert len(result) == 1
        assert result[0].id == source_campaign_1.id
        assert result[0].status == "PUBLISHED"

    @pytest.mark.db
    def test_find_by_criteria_across_different_artists(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        source_campaign_1 = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            global_participant_id=faker.uuid4(),
        )
        source_campaign_2 = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            global_participant_id=faker.uuid4(),
        )
        create_model(
            SourceCampaign,
            vendor_id=faker.pyint(),
            subaccount_id=faker.pyint(),
            global_participant_id=faker.uuid4(),
        )

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=None,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert len(result) == 2
        assert {result[0].id, result[1].id} == {
            source_campaign_1.id,
            source_campaign_2.id,
        }

    @pytest.mark.db
    def test_find_by_criteria_has_other_connections_true(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        source_campaign = create_model(
            SourceCampaign, vendor_id=vendor_id, subaccount_id=subaccount_id
        )
        automated_email_1 = create_model(
            AutomatedEmail,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source_campaign_connections=[
                AutomatedEmailTrigger(source_campaign_id=source_campaign.id)
            ],
        )
        create_model(
            AutomatedEmail,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source_campaign_connections=[
                AutomatedEmailTrigger(source_campaign_id=source_campaign.id)
            ],
        )

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=automated_email_1.id,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert len(result) == 1
        assert result[0].has_other_connections is True

    @pytest.mark.db
    def test_find_by_criteria_has_other_connections_false(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        source_campaign = create_model(
            SourceCampaign, vendor_id=vendor_id, subaccount_id=subaccount_id
        )
        automated_email = create_model(
            AutomatedEmail,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source_campaign_connections=[
                AutomatedEmailTrigger(source_campaign_id=source_campaign.id)
            ],
        )

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=automated_email.id,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert len(result) == 1
        assert result[0].has_other_connections is False

    @pytest.mark.db
    def test_find_by_criteria_has_other_connections_none(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        create_model(SourceCampaign, vendor_id=vendor_id, subaccount_id=subaccount_id)

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=None,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert len(result) == 1
        assert result[0].has_other_connections is None

    @pytest.mark.db
    def test_find_by_criteria_email_type_opt_in_filters_by_double_opt_in_enabled(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        sc_enabled = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            is_double_opt_in_enabled=True,
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            is_double_opt_in_enabled=False,
        )

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=None,
                status=None,
                email_type=AutomatedEmailType.OPT_IN,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert len(result) == 1
        assert result[0].id == sc_enabled.id

    @pytest.mark.db
    def test_find_by_criteria_filters_out_disallowed_sources(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        sc_smf = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="SMF",
        )
        sc_tunespeak = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Tunespeak",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Wyng",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Offerpop",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Webapp",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Wordpress",
        )

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=None,
                status=None,
                email_type=None,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert {sc.id for sc in result} == {sc_smf.id, sc_tunespeak.id}

    @pytest.mark.db
    def test_count_by_criteria_filters_out_disallowed_sources(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="SMF",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Tunespeak",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Wyng",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Offerpop",
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            source="Make The Link",
        )

        count = repository.count_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=None,
                status=None,
                email_type=None,
            )
        )

        assert count == 2

    @pytest.mark.db
    def test_find_by_criteria_email_type_triggered_filters_by_double_opt_in_disabled(
        self,
        repository: SourceCampaignRepository,
        create_model: CreateModel,
        faker: faker.Faker,
    ) -> None:
        vendor_id = faker.pyint()
        subaccount_id = faker.pyint()

        sc_disabled = create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            is_double_opt_in_enabled=False,
        )
        create_model(
            SourceCampaign,
            vendor_id=vendor_id,
            subaccount_id=subaccount_id,
            is_double_opt_in_enabled=True,
        )

        result = repository.find_by_criteria(
            SourceCampaignCriteria(
                search=None,
                vendor_ids={vendor_id},
                subaccount_ids={subaccount_id},
                current_automated_email_id=None,
                status=None,
                email_type=AutomatedEmailType.TRIGGERED,
            ),
            order_by=["name.asc"],
            limit=10,
            offset=0,
        )

        assert len(result) == 1
        assert result[0].id == sc_disabled.id