"""Tests for client setup configuration"""
import pytest

testinfra_hosts = ['borg-client', 'borg-client-2', 'borg-client-multi', 'borg-client-nonroot', 'borg-client-multi-keys']


CLIENT_USER_MAP = {
    'borg-client': 'root',
    'borg-client-2': 'root',
    'borg-client-multi': 'root',
    'borg-client-nonroot': 'backupuser',
    'borg-client-multi-keys': 'root',
}

CLIENT_SSH_KEY_TYPE_MAP = {
    'borg-client': 'rsa',
    'borg-client-2': 'ed25519',
    'borg-client-multi': 'rsa',
    'borg-client-nonroot': 'rsa',
    'borg-client-multi-keys': 'ed25519',
}

CLIENT_SSH_KEY_PER_REPO_MAP = {
    'borg-client': False,
    'borg-client-2': False,
    'borg-client-multi': False,
    'borg-client-nonroot': False,
    'borg-client-multi-keys': True,
}


def get_client_user(host):
    hostname = host.backend.get_hostname()
    return CLIENT_USER_MAP.get(hostname, 'root')


def get_client_ssh_key_type(host):
    hostname = host.backend.get_hostname()
    return CLIENT_SSH_KEY_TYPE_MAP.get(hostname, 'rsa')


def get_client_ssh_key_per_repo(host):
    hostname = host.backend.get_hostname()
    return CLIENT_SSH_KEY_PER_REPO_MAP.get(hostname, False)


def get_client_home(host):
    user = get_client_user(host)
    return f'/home/{user}' if user != 'root' else '/root'


class TestSSHSetup:
    def test_ssh_directory_exists(self, host):
        client_home = get_client_home(host)
        client_user = get_client_user(host)
        ssh_dir = host.file(f'{client_home}/.ssh')
        assert ssh_dir.exists
        assert ssh_dir.is_directory
        assert ssh_dir.user == client_user
        assert ssh_dir.group == client_user
        assert ssh_dir.mode == 0o700

    def test_ssh_private_key_exists(self, host):
        client_home = get_client_home(host)
        client_user = get_client_user(host)
        key_type = get_client_ssh_key_type(host)
        per_repo = get_client_ssh_key_per_repo(host)
        hostname = host.backend.get_hostname()

        if per_repo and hostname == 'borg-client-multi-keys':
            key1 = host.file(f'{client_home}/.ssh/id_{key_type}_borgbackup_borg_server_configs_keys')
            key2 = host.file(f'{client_home}/.ssh/id_{key_type}_borgbackup_borg_server_home_data_keys')
            assert key1.exists
            assert key1.user == client_user
            assert key1.group == client_user
            assert key1.mode == 0o600
            assert key2.exists
            assert key2.user == client_user
            assert key2.group == client_user
            assert key2.mode == 0o600
        else:
            key = host.file(f'{client_home}/.ssh/id_{key_type}')
            assert key.exists
            assert key.user == client_user
            assert key.group == client_user
            assert key.mode == 0o600

    def test_ssh_public_key_exists(self, host):
        client_home = get_client_home(host)
        client_user = get_client_user(host)
        key_type = get_client_ssh_key_type(host)
        per_repo = get_client_ssh_key_per_repo(host)
        hostname = host.backend.get_hostname()

        if per_repo and hostname == 'borg-client-multi-keys':
            key1 = host.file(f'{client_home}/.ssh/id_{key_type}_borgbackup_borg_server_configs_keys.pub')
            key2 = host.file(f'{client_home}/.ssh/id_{key_type}_borgbackup_borg_server_home_data_keys.pub')
            assert key1.exists
            assert key1.user == client_user
            assert key1.group == client_user
            assert key2.exists
            assert key2.user == client_user
            assert key2.group == client_user
        else:
            key = host.file(f'{client_home}/.ssh/id_{key_type}.pub')
            assert key.exists
            assert key.user == client_user
            assert key.group == client_user

    def test_known_hosts_contains_borg_server(self, host):
        client_home = get_client_home(host)
        known_hosts = host.file(f'{client_home}/.ssh/known_hosts')
        assert known_hosts.exists
        assert known_hosts.contains('borg-server')


class TestBackupScript:
    def test_backup_script_exists(self, host):
        hostname = host.backend.get_hostname()
        client_user = get_client_user(host)

        if hostname == 'borg-client-multi':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data')
            assert script1.exists
            assert script1.user == client_user
            assert script1.group == client_user
            assert script1.mode == 0o711
            assert script2.exists
            assert script2.user == client_user
            assert script2.group == client_user
            assert script2.mode == 0o711
        elif hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert script1.exists
            assert script1.user == client_user
            assert script1.group == client_user
            assert script1.mode == 0o711
            assert script2.exists
            assert script2.user == client_user
            assert script2.group == client_user
            assert script2.mode == 0o711
        elif hostname == 'borg-client-nonroot':
            script = host.file('/usr/local/bin/run_borg_backup@borg-server')
            assert script.exists
            assert script.user == client_user
            assert script.group == client_user
            assert script.mode == 0o711
        elif hostname in ('borg-client', 'borg-client-2'):
            script = host.file('/usr/local/bin/run_borg_backup')
            assert script.exists
            assert script.user == client_user
            assert script.group == client_user
            assert script.mode == 0o711
        else:
            pytest.fail(f"Unexpected hostname: {hostname}")

    def test_backup_script_contains_borg_command(self, host):
        hostname = host.backend.get_hostname()

        if hostname == 'borg-client-multi':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data')
            assert script1.contains('borg create')
            assert script2.contains('borg create')
        elif hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert script1.contains('borg create')
            assert script2.contains('borg create')
        elif hostname == 'borg-client-nonroot':
            script = host.file('/usr/local/bin/run_borg_backup@borg-server')
            assert script.contains('borg create')
        elif hostname in ('borg-client', 'borg-client-2'):
            script = host.file('/usr/local/bin/run_borg_backup')
            assert script.contains('borg create')
        else:
            pytest.fail(f"Unexpected hostname: {hostname}")

    def test_backup_script_contains_compression(self, host):
        hostname = host.backend.get_hostname()

        if hostname == 'borg-client-multi':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data')
            assert script1.contains('-C zstd')
            assert script2.contains('-C lz4')
        elif hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert script1.contains('-C zstd')
            assert script2.contains('-C lz4')
        elif hostname == 'borg-client-2':
            script = host.file('/usr/local/bin/run_borg_backup')
            assert script.contains('-C')
            assert script.contains('lz4')
        elif hostname in ('borg-client', 'borg-client-nonroot'):
            script = host.file('/usr/local/bin/run_borg_backup') if hostname == 'borg-client' else host.file('/usr/local/bin/run_borg_backup@borg-server')
            assert script.contains('-C')
            assert script.contains('zstd')
        else:
            pytest.fail(f"Unexpected hostname: {hostname}")

    def test_backup_script_contains_repo_path(self, host):
        hostname = host.backend.get_hostname()

        if hostname == 'borg-client-multi':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data')
            assert script1.contains('borg@borg-server')
            assert script1.contains('/opt/borg/configs')
            assert script2.contains('borg@borg-server')
            assert script2.contains('/opt/borg/home-data')
        elif hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert script1.contains('borg@borg-server')
            assert script1.contains('/opt/borg/configs-keys')
            assert script2.contains('borg@borg-server')
            assert script2.contains('/opt/borg/home-data-keys')
        elif hostname == 'borg-client-nonroot':
            script = host.file('/usr/local/bin/run_borg_backup@borg-server')
            assert script.contains('borg@borg-server')
            assert script.contains('/opt/borg')
        elif hostname == 'borg-client':
            script = host.file('/usr/local/bin/run_borg_backup')
            assert script.contains('borg@borg-server')
            assert script.contains('/opt/borg')
        elif hostname == 'borg-client-2':
            script = host.file('/usr/local/bin/run_borg_backup')
            assert script.contains('backupserver@borg-server-2')
            assert script.contains('/var/backups')
        else:
            pytest.fail(f"Unexpected hostname: {hostname}")

    def test_backup_script_contains_backup_paths(self, host):
        hostname = host.backend.get_hostname()

        if hostname == 'borg-client-multi':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data')
            assert '/etc' in script1.content_string
            assert '/home' in script2.content_string
            assert '--exclude' in script2.content_string
        elif hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert '/etc' in script1.content_string
            assert '/home' in script2.content_string
            assert '--exclude' in script2.content_string
        elif hostname == 'borg-client-nonroot':
            script = host.file('/usr/local/bin/run_borg_backup@borg-server')
            content = script.content_string
            assert '/etc' in content
        elif hostname in ('borg-client', 'borg-client-2'):
            script = host.file('/usr/local/bin/run_borg_backup')
            content = script.content_string
            assert '/etc' in content or '/home' in content
        else:
            pytest.fail(f"Unexpected hostname: {hostname}")

    def test_backup_script_is_executable(self, host):
        hostname = host.backend.get_hostname()

        if hostname == 'borg-client-multi':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data')
            assert script1.mode == 0o711
            assert script2.mode == 0o711
        elif hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert script1.mode == 0o711
            assert script2.mode == 0o711
        elif hostname == 'borg-client-nonroot':
            script = host.file('/usr/local/bin/run_borg_backup@borg-server')
            assert script.mode == 0o711
        elif hostname in ('borg-client', 'borg-client-2'):
            script = host.file('/usr/local/bin/run_borg_backup')
            assert script.mode == 0o711
        else:
            pytest.fail(f"Unexpected hostname: {hostname}")

    def test_backup_script_contains_borg_rsh_when_per_repo(self, host):
        hostname = host.backend.get_hostname()
        per_repo = get_client_ssh_key_per_repo(host)

        if not per_repo:
            return

        if hostname == 'borg-client-multi-keys':
            script1 = host.file('/usr/local/bin/run_borg_backup@configs-keys')
            script2 = host.file('/usr/local/bin/run_borg_backup@home-data-keys')
            assert 'BORG_RSH' in script1.content_string
            assert 'BORG_RSH' in script2.content_string
            assert 'ssh -i' in script1.content_string
            assert 'ssh -i' in script2.content_string


class TestMultiInstanceBaseScript:
    def test_base_script_exists(self, host):
        hostname = host.backend.get_hostname()
        if hostname != 'borg-client-multi':
            return

        client_user = get_client_user(host)
        base_script = host.file('/usr/local/bin/run_borg_backup')
        assert base_script.exists
        assert base_script.user == client_user
        assert base_script.mode == 0o711

    def test_base_script_contains_both_blocks(self, host):
        hostname = host.backend.get_hostname()
        if hostname != 'borg-client-multi':
            return

        base_script = host.file('/usr/local/bin/run_borg_backup')
        content = base_script.content_string

        assert 'borg-server/configs' in content
        assert 'borg-server/home-data' in content

    def test_base_script_contains_both_repos(self, host):
        hostname = host.backend.get_hostname()
        if hostname != 'borg-client-multi':
            return

        base_script = host.file('/usr/local/bin/run_borg_backup')
        content = base_script.content_string

        assert '/opt/borg/configs' in content
        assert '/opt/borg/home-data' in content

    def test_base_script_contains_both_compressions(self, host):
        hostname = host.backend.get_hostname()
        if hostname != 'borg-client-multi':
            return

        base_script = host.file('/usr/local/bin/run_borg_backup')
        content = base_script.content_string

        assert '-C zstd' in content
        assert '-C lz4' in content

    def test_base_script_two_borg_create_commands(self, host):
        hostname = host.backend.get_hostname()
        if hostname != 'borg-client-multi':
            return

        base_script = host.file('/usr/local/bin/run_borg_backup')
        content = base_script.content_string

        assert content.count('borg create') == 2