from unittest.mock import Mock

import factory
from faker import Faker

from atlas_um.auth0.client import Auth0Client
from atlas_um.auth0.models import UserList
from atlas_um.auth0.schemas import UserSchema
from tests.atlas_um.factories.auth0_user_factory import (
    Auth0RoleUserFactory,
    Auth0UserFactory,
    Auth0RoleDataFactory,
)


class TestClient:
    def test_fetch_access_token(self, faker, mocker):
        """Get a fresh access token from Auth0 and store it for use by the
        service.
        """
        fake_client_id = faker.pystr()
        fake_client_secret = faker.pystr()
        fake_access_token = faker.pystr()
        service = Auth0Client(
            None, "fake.auth0.test", fake_client_id, fake_client_secret
        )
        MockedGetToken = mocker.patch("atlas_um.auth0.client.GetToken")
        mocked_client_credentials = (
            MockedGetToken.return_value.client_credentials
        )
        mocked_client_credentials.return_value = {
            "access_token": fake_access_token,
            "refresh_token": faker.pystr(),
            "id_token": faker.pystr(),
            "token_type": "Bearer",
            "expires_in": 86400,
        }

        token = service.fetch_access_token()

        assert token == fake_access_token
        assert service.access_token == fake_access_token
        # assert service.access_token_generated_at
        assert MockedGetToken.call_args_list == [
            mocker.call("fake.auth0.test")
        ]
        assert mocked_client_credentials.call_args_list == [
            mocker.call(
                fake_client_id,
                fake_client_secret,
                "https://fake.auth0.test/api/v2/",
            )
        ]

    def test_list_users_ids(self, mocker):
        auth0 = Auth0Client(None, "fake.auth0.test", access_token="asdf")
        mock_list = self.fake_auth0_role_user_list_resp()
        mocker.patch.object(
            auth0.client.roles, "list"
        ).return_value = self.fake_auth0_roles_list_resp()
        mocker.patch.object(
            auth0.client.roles, "list_users"
        ).return_value = mock_list
        ids = auth0.list_users_ids()
        assert list(ids) == [v.get("user_id") for v in mock_list.get("users")]

    def test_get_user(self, mocker):
        auth0 = Auth0Client(None, "fake.auth0.test", access_token="asdf")
        user = Auth0UserFactory.build()
        user_data = UserSchema().dump(user.dict())
        mocker.patch.object(auth0.client.users, "get").return_value = user_data
        returned_user = auth0.get_user(user.user_id)
        assert returned_user == user

    def test_get_user_roles(self, mocker, faker):
        auth0 = Auth0Client(None, "fake.auth0.test", access_token="asdf")
        role = Auth0RoleDataFactory.build()
        role_data = role.dict()
        mocker.patch.object(auth0.client.users, "list_roles").return_value = {
            "roles": [role_data]
        }
        returned_roles = auth0.get_user_roles(faker.pystr())
        assert returned_roles == [role]

    def test_search_users(self, faker, mocker):
        """Searches Auth0 users by name and email"""
        auth0 = Auth0Client(None, "fake.auth0.test", access_token="asdf")
        mock_list = self.fake_auth0_user_list_resp()
        auth0_client_mock = Mock(return_value=mock_list)
        search_text = faker.first_name()
        mocker.patch.object(auth0.client.users, "list", auth0_client_mock)

        user_list = auth0.search_users(search_text)

        assert user_list == UserList(mock_list)
        term = search_text.lower()
        exp_query = "name:(*{}*) email:(*{}*)".format(term, term)
        auth0.client.users.list.assert_called_once_with(q=exp_query)

    # Helpers
    def fake_auth0_roles_list_resp(self):
        return {"roles": [{"id": "role_id", "name": "role_name"}]}

    def fake_auth0_role_user_list_resp(self):
        user_count = Faker().pyint(min_value=0, max_value=15)
        user_dicts = factory.build_batch(
            dict, user_count, FACTORY_CLASS=Auth0RoleUserFactory
        )
        return {
            "users": user_dicts,
        }

    def fake_auth0_user_list_resp(self):
        user_count = Faker().pyint(min_value=0, max_value=15)
        user_dicts = factory.build_batch(
            dict, user_count, FACTORY_CLASS=Auth0UserFactory
        )
        return {
            "start": 0,
            "limit": 25,
            "length": user_count,
            "users": user_dicts,
            "total": user_count,
        }