import pwd
import grp
from unittest.mock import patch

import ldap3
import pytest

import ceod.utils as utils


def test_api_user_not_found(client):
    status, data = client.get('/api/members/no_such_user')
    assert status == 404
    assert data['error'] == 'user not found'


@pytest.fixture(scope='session')
def mocks_for_create_user():
    with patch.object(utils, 'gen_password') as gen_password_mock, \
            patch.object(pwd, 'getpwuid') as getpwuid_mock, \
            patch.object(grp, 'getgrgid') as getgrgid_mock:
        gen_password_mock.return_value = 'krb5'
        # Normally, if getpwuid or getgrgid do *not* raise a KeyError,
        # then LDAPService will skip that UID. Therefore, by raising a
        # KeyError, we are making sure that the UID will *not* be skipped.
        getpwuid_mock.side_effect = KeyError()
        getgrgid_mock.side_effect = KeyError()
        yield


@pytest.fixture(scope='session')
def create_user_resp(client, mocks_for_create_user):
    status, data = client.post('/api/members', json={
        'uid': 'test_1',
        'cn': 'Test One',
        'program': 'Math',
        'terms': ['s2021'],
    })
    assert status == 200
    assert data[-1]['status'] == 'completed'
    yield status, data
    status, data = client.delete('/api/members/test_1')
    assert status == 200
    assert data[-1]['status'] == 'completed'


@pytest.fixture(scope='session')
def create_user_result(create_user_resp):
    # convenience method
    _, data = create_user_resp
    return data[-1]['result']


def test_api_create_user(cfg, create_user_resp):
    _, data = create_user_resp
    min_uid = cfg.get('members_min_id')
    expected = [
        {"status": "in progress", "operation": "add_user_to_ldap"},
        {"status": "in progress", "operation": "add_group_to_ldap"},
        {"status": "in progress", "operation": "add_user_to_kerberos"},
        {"status": "in progress", "operation": "create_home_dir"},
        {"status": "in progress", "operation": "set_forwarding_addresses"},
        {"status": "in progress", "operation": "send_welcome_message"},
        {"status": "in progress", "operation": "subscribe_to_mailing_list"},
        {"status": "completed", "result": {
            "cn": "Test One",
            "uid": "test_1",
            "uid_number": min_uid,
            "gid_number": min_uid,
            "login_shell": "/bin/bash",
            "home_directory": "/tmp/test_users/test_1",
            "is_club": False,
            "program": "Math",
            "terms": ["s2021"],
            "forwarding_addresses": [],
            "password": "krb5"
        }},
    ]
    assert data == expected


def test_api_next_uid(cfg, client, create_user_result):
    min_uid = cfg.get('members_min_id')
    _, data = client.post('/api/members', json={
        'uid': 'test_2',
        'cn': 'Test Two',
        'program': 'Math',
        'terms': ['s2021'],
    })
    assert data[-1]['status'] == 'completed'
    result = data[-1]['result']
    try:
        assert result['uid_number'] == min_uid + 1
        assert result['gid_number'] == min_uid + 1
    finally:
        client.delete('/api/members/test_2')


def test_api_get_user(cfg, client, create_user_result):
    old_data = create_user_result
    uid = old_data['uid']
    del old_data['password']

    status, data = client.get(f'/api/members/{uid}')
    assert status == 200
    assert data == old_data


def test_api_patch_user(client, create_user_result):
    data = create_user_result
    uid = data['uid']
    prev_login_shell = data['login_shell']
    prev_forwarding_addresses = data['forwarding_addresses']

    # replace login shell
    new_shell = '/bin/sh'
    status, data = client.patch(
        f'/api/members/{uid}', json={'login_shell': new_shell})
    assert status == 200
    expected = [
        {"status": "in progress", "operation": "replace_login_shell"},
        {"status": "completed", "result": "OK"},
    ]
    assert data == expected

    # replace forwarding addresses
    new_forwarding_addresses = [
        'test@example1.internal', 'test@example2.internal',
    ]
    status, data = client.patch(
        f'/api/members/{uid}', json={
            'forwarding_addresses': new_forwarding_addresses
        }
    )
    assert status == 200
    expected = [
        {"status": "in progress", "operation": "replace_forwarding_addresses"},
        {"status": "completed", "result": "OK"},
    ]
    assert data == expected

    # retrieve the user and make sure that both fields were changed
    status, data = client.get(f'/api/members/{uid}')
    assert status == 200
    assert data['login_shell'] == new_shell
    assert data['forwarding_addresses'] == new_forwarding_addresses

    # replace (restore) both
    status, data = client.patch(
        f'/api/members/{uid}', json={
            'login_shell': prev_login_shell,
            'forwarding_addresses': prev_forwarding_addresses
        }
    )
    assert status == 200
    expected = [
        {"status": "in progress", "operation": "replace_login_shell"},
        {"status": "in progress", "operation": "replace_forwarding_addresses"},
        {"status": "completed", "result": "OK"},
    ]
    assert data == expected


def test_api_renew_user(cfg, client, create_user_result, ldap_conn):
    data = create_user_result
    uid = data['uid']
    old_terms = data['terms']
    old_non_member_terms = data.get('non_member_terms', [])

    new_terms = ['f2021']
    status, data = client.post(
        f'/api/members/{uid}/renew', json={'terms': new_terms})
    assert status == 200

    new_non_member_terms = ['w2022', 's2022']
    status, data = client.post(
        f'/api/members/{uid}/renew', json={'non_member_terms': new_non_member_terms})
    assert status == 200

    # check that the changes were applied
    _, data = client.get(f'/api/members/{uid}')
    assert data['terms'] == old_terms + new_terms
    assert data['non_member_terms'] == old_non_member_terms + new_non_member_terms

    # cleanup
    base_dn = cfg.get('ldap_users_base')
    dn = f'uid={uid},{base_dn}'
    changes = {
        'term': [(ldap3.MODIFY_REPLACE, old_terms)],
        'nonMemberTerm': [(ldap3.MODIFY_REPLACE, old_non_member_terms)],
    }
    ldap_conn.modify(dn, changes)


def test_api_reset_password(client, create_user_result):
    uid = create_user_result['uid']
    with patch.object(utils, 'gen_password') as gen_password_mock:
        gen_password_mock.return_value = 'new_password'
        status, data = client.post(f'/api/members/{uid}/pwreset')
        assert status == 200
        assert data['password'] == 'new_password'
    # cleanup
    status, data = client.post(f'/api/members/{uid}/pwreset')
    assert status == 200
    assert data['password'] == 'krb5'