"""
Test configurer
"""

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": "dummy", "DummyAuthenticator": {"password": "<PASSWORD>"}}}
    )
    assert c.JupyterHub.authenticator_class == "dummy"
    assert c.DummyAuthenticator.password == "<PASSWORD>"


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": "<PASSWORD>"}}
    )
    assert c.TraefikTomlProxy.traefik_api_username == "some_user"
    assert c.TraefikTomlProxy.traefik_api_password == "<PASSWORD>"


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"] == "<PASSWORD>"
    c = apply_mock_config(tljh_config)
    assert c.TraefikTomlProxy.traefik_api_password == "<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
