# -*- coding: utf-8 -*-
import os

import pytest
import sh

import dotenv
from dotenv.cli import cli as dotenv_cli
from dotenv.version import __version__


def test_get_key(dotenv_file):
    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'HELLO', 'WORLD')
    stored_value = dotenv.get_key(dotenv_file, 'HELLO')
    assert stored_value == 'WORLD'
    sh.rm(dotenv_file)
    assert dotenv.get_key(dotenv_file, 'HELLO') is None
    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'HELLO', 'WORLD')
    assert success is None


def test_set_key(dotenv_file):
    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'HELLO', 'WORLD')
    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'foo', 'bar')
    assert dotenv.get_key(dotenv_file, 'HELLO') == 'WORLD'

    with open(dotenv_file, 'r') as fp:
        assert 'HELLO="WORLD"\nfoo="bar"' == fp.read().strip()

    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'HELLO', 'WORLD 2')
    assert dotenv.get_key(dotenv_file, 'HELLO') == 'WORLD 2'
    assert dotenv.get_key(dotenv_file, 'foo') == 'bar'

    with open(dotenv_file, 'r') as fp:
        assert 'HELLO="WORLD 2"\nfoo="bar"' == fp.read().strip()

    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, "HELLO", "WORLD\n3")

    with open(dotenv_file, "r") as fp:
        assert 'HELLO="WORLD\n3"\nfoo="bar"' == fp.read().strip()


def test_set_key_permission_error(dotenv_file):
    os.chmod(dotenv_file, 0o000)

    with pytest.raises(Exception):
        dotenv.set_key(dotenv_file, "HELLO", "WORLD")

    os.chmod(dotenv_file, 0o600)
    with open(dotenv_file, "r") as fp:
        assert fp.read() == ""


def test_list(cli, dotenv_file):
    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'HELLO', 'WORLD')
    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'list'])
    assert result.exit_code == 0, result.output
    assert result.output == 'HELLO=WORLD\n'


def test_get_cli(cli, dotenv_file):
    cli.invoke(dotenv_cli, ['--file', dotenv_file, 'set', 'HELLO', "WORLD 1"])
    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'get', 'HELLO'])
    assert result.exit_code == 0, result.output
    assert result.output == 'HELLO=WORLD 1\n'


def test_list_wo_file(cli):
    result = cli.invoke(dotenv_cli, ['--file', 'doesnotexists', 'list'])
    assert result.exit_code == 2, result.output
    assert 'Invalid value for "-f"' in result.output


def test_empty_value(dotenv_file):
    with open(dotenv_file, "w") as f:
        f.write("TEST=")
    assert dotenv.get_key(dotenv_file, "TEST") == ""


def test_key_value_without_quotes(dotenv_file):
    with open(dotenv_file, 'w') as f:
        f.write("TEST = value \n")
    assert dotenv.get_key(dotenv_file, 'TEST') == "value"


def test_key_value_without_quotes_with_spaces(dotenv_file):
    with open(dotenv_file, 'w') as f:
        f.write('TEST = " with spaces " \n')
    assert dotenv.get_key(dotenv_file, 'TEST') == " with spaces "


def test_value_with_double_quotes(dotenv_file):
    with open(dotenv_file, 'w') as f:
        f.write('TEST="two words"\n')
    assert dotenv.get_key(dotenv_file, 'TEST') == 'two words'


def test_value_with_simple_quotes(dotenv_file):
    with open(dotenv_file, 'w') as f:
        f.write("TEST='two words'\n")
    assert dotenv.get_key(dotenv_file, 'TEST') == 'two words'


def test_value_with_special_characters(dotenv_file):
    with open(dotenv_file, 'w') as f:
        f.write(r'TEST="}=&~{,(\5%{&;"')
    assert dotenv.get_key(dotenv_file, 'TEST') == r'}=&~{,(\5%{&;'


def test_value_with_new_lines(dotenv_file):
    with open(dotenv_file, 'w') as f:
        f.write('TEST="a\nb"')
    assert dotenv.get_key(dotenv_file, 'TEST') == "a\nb"


def test_value_after_comment(dotenv_file):
    with open(dotenv_file, "w") as f:
        f.write("# comment\nTEST=a")
    assert dotenv.get_key(dotenv_file, "TEST") == "a"


def test_unset_ok(dotenv_file):
    with open(dotenv_file, "w") as f:
        f.write("a=b\nc=d")

    success, key_to_unset = dotenv.unset_key(dotenv_file, "a")

    assert success is True
    assert key_to_unset == "a"
    with open(dotenv_file, "r") as f:
        assert f.read() == "c=d"


def test_unset_non_existing_file():
    success, key_to_unset = dotenv.unset_key('/non-existing', 'HELLO')

    assert success is None


def test_unset_cli(cli, dotenv_file):
    success, key_to_set, value_to_set = dotenv.set_key(dotenv_file, 'TESTHELLO', 'WORLD')
    dotenv.get_key(dotenv_file, 'TESTHELLO') == 'WORLD'
    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'unset', 'TESTHELLO'])
    assert result.exit_code == 0, result.output
    assert result.output == 'Successfully removed TESTHELLO\n'
    dotenv.get_key(dotenv_file, 'TESTHELLO') is None
    result = cli.invoke(dotenv_cli, ['--file', dotenv_file, 'unset', 'TESTHELLO'])
    assert result.exit_code == 1, result.output


@pytest.mark.parametrize(
    "quote_mode,variable,value,expected",
    (
        ("always", "HELLO", "WORLD", 'HELLO="WORLD"\n'),
        ("never", "HELLO", "WORLD", 'HELLO=WORLD\n'),
        ("auto", "HELLO", "WORLD", 'HELLO=WORLD\n'),
        ("auto", "HELLO", "HELLO WORLD", 'HELLO="HELLO WORLD"\n'),
    )
)
def test_console_script(quote_mode, variable, value, expected, dotenv_file):
    sh.dotenv('-f', dotenv_file, '-q', quote_mode, 'set', variable, value)

    result = sh.cat(dotenv_file)

    assert result == expected


def test_set_non_existing_file(cli):
    result = cli.invoke(dotenv.cli.set, ['my_key', 'my_value'])

    assert result.exit_code != 0


def test_get_non_existing_file(cli):
    result = cli.invoke(dotenv.cli.get, ['my_key'])

    assert result.exit_code != 0


def test_list_non_existing_file(cli):
    result = cli.invoke(dotenv.cli.set, [])

    assert result.exit_code != 0


def test_default_path(tmp_path):
    sh.cd(str(tmp_path))
    sh.touch(tmp_path / '.env')
    sh.dotenv('set', 'HELLO', 'WORLD')

    result = sh.dotenv('get', 'HELLO')

    assert result == 'HELLO=WORLD\n'


def test_get_key_with_interpolation(dotenv_file):
    sh.touch(dotenv_file)
    dotenv.set_key(dotenv_file, 'HELLO', 'WORLD')
    dotenv.set_key(dotenv_file, 'FOO', '${HELLO}')
    dotenv.set_key(dotenv_file, 'BAR', 'CONCATENATED_${HELLO}_POSIX_VAR')

    with open(dotenv_file) as f:
        lines = f.readlines()
    assert lines == [
        'HELLO="WORLD"\n',
        'FOO="${HELLO}"\n',
        'BAR="CONCATENATED_${HELLO}_POSIX_VAR"\n',
    ]

    # test replace from variable in file
    stored_value = dotenv.get_key(dotenv_file, 'FOO')
    assert stored_value == 'WORLD'
    stored_value = dotenv.get_key(dotenv_file, 'BAR')
    assert stored_value == 'CONCATENATED_WORLD_POSIX_VAR'
    # test replace from environ taking precedence over file
    os.environ["HELLO"] = "TAKES_PRECEDENCE"
    stored_value = dotenv.get_key(dotenv_file, 'FOO')
    assert stored_value == "TAKES_PRECEDENCE"


def test_get_key_with_interpolation_of_unset_variable(dotenv_file):
    dotenv.set_key(dotenv_file, 'FOO', '${NOT_SET}')
    # test unavailable replacement returns empty string
    stored_value = dotenv.get_key(dotenv_file, 'FOO')
    assert stored_value == ''
    # unless present in environment
    os.environ['NOT_SET'] = 'BAR'
    stored_value = dotenv.get_key(dotenv_file, 'FOO')
    assert stored_value == 'BAR'
    del(os.environ['NOT_SET'])


def test_run(tmp_path):
    dotenv_file = tmp_path / '.env'
    dotenv_file.touch()
    sh.cd(str(tmp_path))
    dotenv.set_key(str(dotenv_file), 'FOO', 'BAR')
    result = sh.dotenv('run', 'printenv', 'FOO').strip()
    assert result == 'BAR'


def test_run_with_other_env(tmp_path):
    dotenv_name = 'dotenv'
    dotenv_file = tmp_path / dotenv_name
    dotenv_file.touch()
    sh.cd(str(tmp_path))
    sh.dotenv('--file', dotenv_name, 'set', 'FOO', 'BAR')
    result = sh.dotenv('--file', dotenv_name, 'run', 'printenv', 'FOO').strip()
    assert result == 'BAR'


def test_run_without_cmd(cli):
    result = cli.invoke(dotenv_cli, ['run'])
    assert result.exit_code != 0


def test_run_with_invalid_cmd(cli):
    result = cli.invoke(dotenv_cli, ['run', 'i_do_not_exist'])
    assert result.exit_code != 0


def test_run_with_version(cli):
    result = cli.invoke(dotenv_cli, ['--version'])
    print(vars(result))
    assert result.exit_code == 0
    assert result.output.strip().endswith(__version__)