from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.contrib.auth.backends import ModelBackend
from django.conf import settings
from django.db import transaction

from test_oauth import verifiers
from test_oauth.models import TESTOAuth2Data, Character
from test_oauth.session import TESTOAuth2Session


DEFAULT_VERIFIERS = [
    verifiers.TESTMembershipVerifier()
]


class TESTOAuth2Backend(ModelBackend):
    def authenticate(self, token=None, **kwargs):
        if token is None:
            return None

        profile = TESTOAuth2Session(token=token).profile

        self.run_verifiers(profile)

        if getattr(settings, 'TEST_OAUTH_RESPECT_ID', False):
            user, _ = get_user_model().objects.update_or_create(
                pk=profile['id'],
                defaults={
                    'username': profile['username']
                }
            )
        else:
            user, _ = get_user_model().objects.get_or_create(
                username=profile['username']
            )

        data, _ = TESTOAuth2Data.objects.update_or_create(
            user=user,
            defaults={
                'access_token': token['access_token'],
                'refresh_token': token['refresh_token'],
                'auth_id': profile['id']
            }
        )

        if getattr(settings, 'TEST_OAUTH_CREATE_GROUPS', False):
            self._do_create_groups(
                user,
                profile.get('groups', [])
            )

        if getattr(settings, 'TEST_OAUTH_CREATE_CHARACTERS', False):
            self._do_create_characters(
                user,
                profile.get('characters', []),
                profile.get('primary_character', None),
            )

        return user

    def run_verifiers(self, profile):
        verifiers = getattr(
            settings,
            'TEST_OAUTH_VERIFIERS',
            DEFAULT_VERIFIERS
        )

        for v in verifiers:
            v(**profile)

    def get_user(self, user_id):
        UserModel = get_user_model()

        try:
            return UserModel.objects.get(pk=user_id)
        except UserModel.DoesNotExist:
            return None

    @transaction.atomic
    def _do_create_groups(self, user, groups):
        user.groups.clear()

        for g in groups:
            group, _ = Group.objects.update_or_create(
                id=g['id'],
                defaults={
                    'name': g['name']
                }
            )

            user.groups.add(group)

            # Adding carveout for Server Admin group
            if g['name'] == "Server Admin":
                user.is_staff = True
                user.is_superuser = True

        user.save()

    @transaction.atomic
    def _do_create_characters(self, user, characters, primary):
        user.auth.characters.clear()
        user.auth.primary_character = None

        for c in characters:
            character, _ = Character.objects.update_or_create(
                id=c['id'],
                defaults={
                    'name': c['name'],
                    'alliance_id': (c['alliance'] or {'id': None})['id'],
                    'corporation_id': c['corporation']['id']
                }
            )

            user.auth.characters.add(character)

        user.auth.primary_character_id = primary['id']
        user.auth.save()