import pytest
import flask
from flask import url_for
from pytest_lazyfixture import lazy_fixture

from atlas_um.admin_settings import forms, services
from atlas_um.pgdb import ClaimValue
from tests.atlas_um import factories, pytest_helpers


@pytest.mark.parametrize(
    "endpoint, filter_args, form, service",
    [
        (
            "admin_settings.business_units",
            {},
            forms.BusinessUnitForm,
            services.UpdateBusinessUnitService,
        ),
        (
            "admin_settings.job_categories",
            {},
            forms.JobCategoryForm,
            services.UpdateJobCategoryService,
        ),
        (
            "admin_settings.personnel_types",
            {},
            forms.PersonnelTypeForm,
            services.UpdatePersonnelTypeService,
        ),
        (
            "admin_settings.tags",
            {},
            forms.TagForm,
            services.UpdateTagService,
        ),
        (
            "admin_settings.resource_groups",
            {},
            forms.ResourceGroupForm,
            services.UpdateResourceGroupService,
        ),
        (
            "admin_settings.claim_names",
            {"resource_group_id": "1"},
            forms.ClaimNameForm,
            services.UpdateClaimNameService,
        ),
        (
            "admin_settings.claim_values",
            {"claim_name_id": "1"},
            forms.ClaimValueForm,
            services.UpdateClaimValueService,
        ),
        (
            "admin_settings.internal_domains",
            {},
            forms.InternalUserDomainForm,
            services.UpdateInternalUserDomainService,
        ),
    ],
)
class TestViews:
    def test_get_failure_authentication(
        self, app, endpoint, filter_args, form, service
    ):
        with app.test_client() as client:
            resp = client.get(url_for(endpoint, **filter_args))
        assert resp.status_code == 302

    def test_get_failure_authorization(
        self, app, authenticated, endpoint, filter_args, form, service
    ):
        with app.test_client() as client:
            resp = client.get(url_for(endpoint, **filter_args))
        assert resp.status_code == 401

    @pytest.mark.parametrize(
        "authorized_user, status",
        [
            (lazy_fixture("authorized_manager"), 401),
        ],
    )
    def test_admin_view_no_access(
        self,
        app,
        endpoint,
        filter_args,
        form,
        service,
        authorized_user,
        status,
    ):
        with app.test_client() as client:
            resp = client.get(url_for(endpoint, **filter_args))
            assert resp.status_code == status

    def test_get_success(
        self,
        app,
        pgdb_session,
        authorized_admin,
        mocker,
        endpoint,
        filter_args,
        form,
        service,
    ):
        if filter_args:
            claim_name = factories.ClaimNameFactory.build()
            pgdb_session.add(claim_name)
            pgdb_session.commit()
            filter_args["claim_name_id"] = claim_name.id
            filter_args["resource_group_id"] = claim_name.resource_group.id
        with app.test_client() as client:
            resp = client.get(url_for(endpoint, **filter_args))
        assert resp.status_code == 200

    def test_post_failure_authentication(
        self, app, endpoint, mocker, filter_args, form, service
    ):
        mocked_validate, mocked_execute = self._get_mocked_validate_execute(
            mocker, form, service
        )
        with app.test_client() as client:
            resp = client.post(url_for(endpoint, **filter_args))
        assert resp.status_code == 302
        assert not mocked_validate.called
        assert not mocked_execute.called

    def test_post_failure_authorization(
        self, app, authenticated, mocker, endpoint, filter_args, form, service
    ):
        mocked_validate, mocked_execute = self._get_mocked_validate_execute(
            mocker, form, service
        )
        with app.test_client() as client:
            resp = client.post(url_for(endpoint, **filter_args))
        assert resp.status_code == 401
        assert not mocked_validate.called
        assert not mocked_execute.called

    def test_post_success(
        self,
        app,
        authorized_admin,
        mocker,
        endpoint,
        filter_args,
        form,
        service,
    ):
        mocked_validate, mocked_execute = self._get_mocked_validate_execute(
            mocker, form, service, True
        )
        with app.test_client() as client:
            resp = client.post(url_for(endpoint, **filter_args))
        assert resp.status_code == 302
        assert mocked_validate.called
        assert mocked_execute.called

    def _get_mocked_validate_execute(self, mocker, form, service, valid=False):
        mocked_validate = mocker.patch.object(form, "validate_on_submit")
        del mocked_validate._formfield
        mocked_validate.return_value = valid
        mocked_execute = mocker.patch.object(service, "execute")
        return mocked_validate, mocked_execute


class TestClaimValueChildren(pytest_helpers.UrlForThisMixin):
    ENDPOINT = "common.claim_value_children"

    def test_get_failure_authentication(self, app, faker):
        claim_value_id = faker.pyint()
        with app.test_client() as client:
            resp = client.get(
                self.url_for_this(app, claim_value_id=claim_value_id)
            )
        assert resp.status_code == 302

    def test_get_failure_authorization(self, app, authenticated, faker):
        claim_value_id = faker.pyint()
        with app.test_client() as client:
            resp = client.get(
                self.url_for_this(app, claim_value_id=claim_value_id)
            )
        assert resp.status_code == 401

    def test_get_failure_no_claim_value(
        self, app, authorized_admin, faker, pgdb_session, mocker
    ):
        claim_value = factories.ClaimValueFactory.build()
        pgdb_session.add(claim_value)
        pgdb_session.commit()
        mocker.spy(flask, "render_template")
        url = self.url_for_this(
            app, claim_value_id=claim_value.id + faker.pyint(min_value=1)
        )
        with app.test_client() as client:
            resp = client.get(url)
        assert resp.status_code == 404

    def test_get_success(
        self, app, authorized_admin, faker, pgdb_session, mocker
    ):
        claim_value = factories.ClaimValueFactory.build()
        pgdb_session.add(claim_value)
        pgdb_session.commit()
        mocker.spy(flask, "render_template")
        url = self.url_for_this(app, claim_value_id=claim_value.id)
        with app.test_client() as client:
            resp = client.get(url)
        assert resp.status_code == 200

        with app.test_request_context(url):
            claim_value = ClaimValue.query.get(claim_value.id)
            render_expects = mocker.call(
                "common/children_modal_content.html",
                claim_value=claim_value,
                children=[],
            )
        assert flask.render_template.call_args_list == [render_expects]