"""
Test configurer
"""

from traitlets import Dict
from traitlets.config import Config
import os
import sys

from tljh import configurer





def apply_mock_config(overrides):
    """
    Configure a mock configurer with given overrides.

    overrides should be a dict that matches what you parse from a config.yaml
    """
    c = Config()
    configurer.apply_config(overrides, c)
    return c


def test_default_base_url():
    """
    Test default JupyterHub base_url
    """
    c = apply_mock_config({})
    assert c.JupyterHub.base_url == '/'


def test_set_base_url():
    """
    Test set JupyterHub base_url
    """
    c = apply_mock_config({'base_url': '/custom-base'})
    assert c.JupyterHub.base_url == '/custom-base'


def test_default_memory_limit():
    """
    Test default per user memory limit
    """
    c = apply_mock_config({})
    assert c.Spawner.mem_limit is None


def test_set_memory_limit():
    """
    Test setting per user memory limit
    """
    c = apply_mock_config({'limits': {'memory': '42G'}})
    assert c.Spawner.mem_limit == '42G'


def test_app_default():
    """
    Test default application with no config overrides.
    """
    c = apply_mock_config({})
    # default_url is not set, so JupyterHub will pick default.
    assert 'default_url' not in c.Spawner


def test_app_jupyterlab():
    """
    Test setting JupyterLab as default application
    """
    c = apply_mock_config({'user_environment': {'default_app': 'jupyterlab'}})
    assert c.Spawner.default_url == '/lab'


def test_app_nteract():
    """
    Test setting nteract as default application
    """
    c = apply_mock_config({'user_environment': {'default_app': 'nteract'}})
    assert c.Spawner.default_url == '/nteract'


def test_auth_default():
    """
    Test default authentication settings with no overrides
    """
    c = apply_mock_config({})

    assert c.JupyterHub.authenticator_class == 'firstuseauthenticator.FirstUseAuthenticator'
    # Do not auto create users who haven't been manually added by default
    assert not c.FirstUseAuthenticator.create_users


def test_auth_dummy():
    """
    Test setting Dummy Authenticator & password
    """
    c = apply_mock_config({
        'auth': {
            'type': 'dummyauthenticator.DummyAuthenticator',
            'DummyAuthenticator': {
                'password': 'test'
            }
        }
    })
    assert c.JupyterHub.authenticator_class == 'dummyauthenticator.DummyAuthenticator'
    assert c.DummyAuthenticator.password == 'test'


def test_user_groups():
    """
    Test setting user groups
    """
    c = apply_mock_config({
        'users': {
            'extra_user_groups': {
                "g1": ["u1", "u2"],
                "g2": ["u3", "u4"]
            },
        }
    })
    assert c.UserCreatingSpawner.user_groups == {
        "g1": ["u1", "u2"],
        "g2": ["u3", "u4"]
    }


def test_auth_firstuse():
    """
    Test setting FirstUse Authenticator options
    """
    c = apply_mock_config({
        'auth': {
            'type': 'firstuseauthenticator.FirstUseAuthenticator',
            'FirstUseAuthenticator': {
                'create_users': True
            }
        }
    })
    assert c.JupyterHub.authenticator_class == 'firstuseauthenticator.FirstUseAuthenticator'
    assert c.FirstUseAuthenticator.create_users


def test_auth_github():
    """
    Test using GitHub authenticator
    """
    c = apply_mock_config({
        'auth': {
            'type': 'oauthenticator.github.GitHubOAuthenticator',
            'GitHubOAuthenticator': {
                'client_id': 'something',
                'client_secret': 'something-else'
            }
        }
    })
    assert c.JupyterHub.authenticator_class == 'oauthenticator.github.GitHubOAuthenticator'
    assert c.GitHubOAuthenticator.client_id == 'something'
    assert c.GitHubOAuthenticator.client_secret == 'something-else'


def test_traefik_api_default():
    """
    Test default traefik api authentication settings with no overrides
    """
    c = apply_mock_config({})

    assert c.TraefikTomlProxy.traefik_api_username == 'api_admin'
    assert len(c.TraefikTomlProxy.traefik_api_password) == 0


def test_set_traefik_api():
    """
    Test setting per traefik api credentials
    """
    c = apply_mock_config({
        'traefik_api': {
            'username': 'some_user',
            'password': '1234'
        }
    })
    assert c.TraefikTomlProxy.traefik_api_username == 'some_user'
    assert c.TraefikTomlProxy.traefik_api_password == '1234'


def test_cull_service_default():
    """
    Test default cull service settings with no overrides
    """
    c = apply_mock_config({})

    cull_cmd = [
        sys.executable, '-m', 'jupyterhub_idle_culler',
        '--timeout=600', '--cull-every=60', '--concurrency=5',
        '--max-age=0'
    ]
    assert c.JupyterHub.services == [{
        'name': 'cull-idle',
        'admin': True,
        'command': cull_cmd,
    }]


def test_set_cull_service():
    """
    Test setting cull service options
    """
    c = apply_mock_config({
        'services': {
            'cull': {
                'every': 10,
                'users': True,
                'max_age': 60
            }
        }
    })
    cull_cmd = [
        sys.executable, '-m', 'jupyterhub_idle_culler',
        '--timeout=600', '--cull-every=10', '--concurrency=5',
        '--max-age=60', '--cull-users'
    ]
    assert c.JupyterHub.services == [{
        'name': 'cull-idle',
        'admin': True,
        'command': cull_cmd,
    }]


def test_load_secrets(tljh_dir):
    """
    Test loading secret files
    """
    with open(os.path.join(tljh_dir, 'state', 'traefik-api.secret'), 'w') as f:
        f.write("traefik-password")

    tljh_config = configurer.load_config()
    assert tljh_config['traefik_api']['password'] == "traefik-password"
    c = apply_mock_config(tljh_config)
    assert c.TraefikTomlProxy.traefik_api_password == "traefik-password"


def test_auth_native():
    """
    Test setting Native Authenticator
    """
    c = apply_mock_config({
        'auth': {
            'type': 'nativeauthenticator.NativeAuthenticator',
            'NativeAuthenticator': {
                'open_signup': True,
            }
        }
    })
    assert c.JupyterHub.authenticator_class == 'nativeauthenticator.NativeAuthenticator'
    assert c.NativeAuthenticator.open_signup == True