from werkzeug.datastructures import ImmutableMultiDict

from atlas_um.dna_accounts.forms import DNAAccountForm
from tests.atlas_um import factories
from tests.atlas_um.factories import DNAAccountFactory
from tests.atlas_um.pytest_helpers import UrlForThisMixin


class TestDNAAccountForm(UrlForThisMixin):

    ENDPOINT = "dna_accounts.edit"

    def test_validation_success_all_fields(self, pgdb_session):
        account = DNAAccountFactory.build()
        pgdb_session.add(account)
        pgdb_session.commit()
        form_data = DNAAccountForm(obj=account).dump()
        form = DNAAccountForm(form_data=form_data, obj=account)
        assert form.validate()

    def test_validation_failure_dna_invitation(self, pgdb_session):
        account = DNAAccountFactory.build(usm_account=None)
        pgdb_session.add(account)
        pgdb_session.commit()
        cleanup_fields = {
            "given_name",
            "family_name",
            "email",
        }
        form_data = DNAAccountForm(obj=account).dump(
            cleanup_fields=cleanup_fields
        )
        form = DNAAccountForm(formdata=form_data, obj=account)
        assert not form.validate()
        assert cleanup_fields == set(form.errors)

    def test_keep_expiration_date_for_edit_active(
        self, app, pgdb_session, faker
    ):
        account = DNAAccountFactory.build(expiration_date=faker.future_date())
        pgdb_session.add(account)
        pgdb_session.commit()
        form = DNAAccountForm(obj=account)
        assert form["expiration_date"].data == account.expiration_date

    def test_cleanup_expiration_date_for_reactivation(
        self, pgdb_session, faker
    ):
        account = DNAAccountFactory.build(expiration_date=faker.past_date())
        pgdb_session.add(account)
        pgdb_session.commit()
        form = DNAAccountForm(obj=account)
        assert form["expiration_date"].data is None

    def test_validation_success_new_user(self, app, faker, pgdb_session):
        business_unit = factories.BusinessUnitFactory.build()
        job_category = factories.JobCategoryFactory.build()
        personnel_type = factories.PersonnelTypeFactory.build()
        pgdb_session.add(business_unit)
        pgdb_session.add(job_category)
        pgdb_session.add(personnel_type)
        pgdb_session.commit()

        form_data = {
            "given_name": faker.first_name(),
            "family_name": faker.last_name(),
            "email": faker.email(),
            "is_sony_employee": "y",
            "is_vip": "y",
            "job_category": str(job_category.id),
            "business_unit": str(business_unit.id),
            "personnel_type": str(personnel_type.id),
            "expiration_date": f"{faker.future_date():%m/%d/%y}",
            "supervisor_email": faker.email(),
            "supervisor_name": faker.name(),
        }
        form = DNAAccountForm(formdata=ImmutableMultiDict(form_data))
        assert form.validate(), form.errors

    def test_validation_failure_new_user_required_fields(
        self, faker, pgdb_session
    ):
        business_unit = factories.BusinessUnitFactory.build()
        job_category = factories.JobCategoryFactory.build()
        personnel_type = factories.PersonnelTypeFactory.build()
        pgdb_session.add(business_unit)
        pgdb_session.add(job_category)
        pgdb_session.add(personnel_type)
        pgdb_session.commit()

        expected_error_fields = {"given_name", "family_name", "email"}
        form_data = {
            "is_sony_employee": "y",
            "is_vip": "y",
            "job_category": str(job_category.id),
            "business_unit": str(business_unit.id),
            "personnel_type": str(personnel_type.id),
            "expiration_date": f"{faker.future_date():%m/%d/%y}",
            "supervisor_email": faker.email(),
            "supervisor_name": faker.name(),
        }
        form = DNAAccountForm(formdata=ImmutableMultiDict(form_data))
        assert not form.validate()
        assert expected_error_fields == set(form.errors)

    def test_validation_failure_duplicate_email_create(
        self, app, faker, pgdb_session
    ):
        existing_email = faker.email()
        existing_account = DNAAccountFactory.build(email=existing_email)
        business_unit = factories.BusinessUnitFactory.build()
        job_category = factories.JobCategoryFactory.build()
        personnel_type = factories.PersonnelTypeFactory.build()
        pgdb_session.add(existing_account)
        pgdb_session.add(business_unit)
        pgdb_session.add(job_category)
        pgdb_session.add(personnel_type)
        pgdb_session.commit()

        form_data = {
            "given_name": faker.first_name(),
            "family_name": faker.last_name(),
            "email": existing_email,
            "is_sony_employee": "y",
            "is_vip": "y",
            "job_category": str(job_category.id),
            "business_unit": str(business_unit.id),
            "personnel_type": str(personnel_type.id),
            "expiration_date": f"{faker.future_date():%m/%d/%y}",
            "supervisor_email": faker.email(),
            "supervisor_name": faker.name(),
        }
        form = DNAAccountForm(formdata=ImmutableMultiDict(form_data))
        assert not form.validate()
        assert {"email": ["The account is already exists"]} == form.errors

    def test_validation_failure_duplicate_email_update(
        self, app, faker, pgdb_session
    ):
        existing_email = faker.email()
        editable_email = faker.email()
        existing_account = DNAAccountFactory.build(
            email=existing_email,
        )
        editable_account = DNAAccountFactory.build(
            email=editable_email,
        )

        business_unit = factories.BusinessUnitFactory.build()
        job_category = factories.JobCategoryFactory.build()
        personnel_type = factories.PersonnelTypeFactory.build()
        pgdb_session.add(existing_account)
        pgdb_session.add(editable_account)
        pgdb_session.add(business_unit)
        pgdb_session.add(job_category)
        pgdb_session.add(personnel_type)
        pgdb_session.commit()

        form_data = {
            "given_name": faker.first_name(),
            "family_name": faker.last_name(),
            "email": existing_account.email,
            "is_sony_employee": "y",
            "is_vip": "y",
            "job_category": str(job_category.id),
            "business_unit": str(business_unit.id),
            "personnel_type": str(personnel_type.id),
            "expiration_date": f"{faker.future_date():%m/%d/%y}",
            "supervisor_email": faker.email(),
            "supervisor_name": faker.name(),
        }
        form = DNAAccountForm(
            formdata=ImmutableMultiDict(form_data), obj=editable_account
        )
        assert not form.validate()
        assert {"email": ["The account is already exists"]} == form.errors