import random, os
from fabric import task
from fabric import Connection
from fabric import Config
from invoke import Responder


REPO_LINK = os.getenv("REPO_LINK")
JENKINS_DIR = os.getenv("JENKINS_DIR")
IS_PROD = os.getenv("PROD_REQS", False)
DB_NAME = "mywebsite"
DOMAIN_NAME = None
DOMAIN_NAME_TEST = os.getenv("DOMAIN_NAME_TEST")


@task
def site_directory_status(c):
    expected_path = f"/home/{c.user}/sites/{c.host}/"
    result = c.run(f"if test -d {expected_path};then echo 'True'; else echo 'False';fi")
    if result.stdout == "True":
        return expected_path
    else:
        # path is possibly a jenkins workspace for testing
        pass


def _get_site_folder(user, host):
    return f"/home/{user}/sites/{host}/"


@task
def get_latest_source(c):
    current_commit = _get_current_commit(c)
    dir_ = _get_site_folder(c.user, c.host)
    with c.cd(dir_):
        _get_latest_source(c, current_commit)


@task
def deploy(c, commit=None):
    """deploy to website, argument is a switch for commit type either main or local, defaults to local"""
    site_folder = f"/home/{c.user}/sites/{c.host}"
    current_commit = _get_current_commit(c) if not commit else _get_main_commit(c)

    provision_database(c)
    c.run(f"mkdir -p {site_folder}")
    # django needs this to be able to read env file
    c.config.run.env = {"DJANGO_READ_DOT_ENV_FILE": True}
    c.config.run.env = {"DOMAIN_NAME_TEST": os.getenv("DOMAIN_NAME_TEST")}
    with c.cd(site_folder):
        _get_latest_source(c, current_commit)
        _update_virtualenv(c)
        _create_or_update_dotenv(c)
        _update_static_files(c)
        _migrate_database(c)
        _provision_nginx_gunicorn_conf(c)


def _get_current_commit(c):
    return c.local("git log -n 1 --format=%H")


def _get_main_commit(c):
    return c.local("git rev-parse main")


def _get_latest_source(c, current_commit):
    """get latest source code from repo onto server"""
    # check ssh connection
    _git_ssh_check(c)
    is_git_repo = c.run('if test -d .git;then echo "True";else echo "False"; fi').stdout
    is_git_repo = is_git_repo.rstrip()
    if is_git_repo == "False":
        # git repo does not exist thus clone repo
        c.run(f"git clone {REPO_LINK} .")
    else:
        c.run("git fetch")
    current_commit_stdout = (current_commit.stdout).strip("\n")
    c.run(f"git reset --hard {current_commit_stdout}")


SSH_KEY_NAME = os.getenv("SSH_KEY_NAME")


def _git_ssh_check(c):
    core_command_check = f""" if [ "$(git config core.sshCommand)" = '' ]; then
        echo "git ssh identity file not set! Setting identity file..."
        git config core.sshCommand "ssh -i ~/.ssh/{SSH_KEY_NAME}"
    else
        echo "identity file already set!"
    fi
    """
    c.run(core_command_check)


def _update_virtualenv(c):
    dir_exists = c.run(
        f'if test -d .venv/;then echo "True";else echo "False";fi'
    ).stdout
    dir_exists = dir_exists.rstrip()
    if dir_exists == "False":
        c.run(f"/home/shiba/.pyenv/shims/pip install virtualenv")
        c.run(f"/home/shiba/.pyenv/shims/python -m virtualenv .venv")
    reqs = "requirements/"
    reqs += "local.txt" if not IS_PROD else "production.txt"
    c.run(f".venv/bin/pip install -r {reqs}")


def _create_or_update_dotenv(c):
    keys = [
        "DJANGO_DEBUG_FALSE",
        "SITENAME",
        "DJANGO_SECRET_KEY",
        "EMAIL_APP_PASSW",
        "DATABASE_URL",
        "TEST_URL",
        "REDIS_URL",
        "DJANGO_ADMIN_URL",
        "USE_SMTP_BACKEND",
        "MAINTENANCE_MODE_ON",
        "LOCAL_TESTING",
        "DOMAIN_NAME_TEST",
        "SMTP_EMAIL_TEST",
        # django needs this to be able to read env file
        "DJANGO_READ_DOT_ENV_FILE",
    ]

    current_contents = None
    if c.run("test -f .env", warn=True).failed:
        c.run("touch .env")
    else:
        # get contents from .env for checking
        current_contents = ((c.run("cat .env")).stdout).strip("\n")

    def echoer(key, value):
        """echos missing key value pairs into .env file"""
        if not current_contents or not key in current_contents:
            c.run(f'echo "{key}={value}" >> .env')

    # sort by alphabetical, for convenience
    keys.sort()

    for key in keys:
        match key:
            case "DJANGO_DEBUG_FALSE":
                echoer(key, "y")
            case "SITENAME":
                echoer(key, c.host)
            case "DJANGO_SECRET_KEY":
                new_secret = "".join(
                    random.SystemRandom().choices(
                        "abcdefghijklmnopqrstuvwxyz0123456789", k=50
                    )
                )
                echoer(key, new_secret)
            case "EMAIL_APP_PASSW":
                echoer(key, f"'{os.getenv(key)}'")
            case "DATABASE_URL":
                echoer(key, os.getenv("DATABASE_URL"))
            case "TEST_URL":
                echoer(key, os.getenv("TEST_URL"))
            case "REDIS_URL":
                echoer(key, "")
            case "DJANGO_ADMIN_URL":
                echoer(key, os.getenv("DJANGO_ADMIN_URL"))
            case "USE_SMTP_BACKEND":
                echoer(key, "y")
            case "MAINTENANCE_MODE_ON":
                echoer(key, "")
            case "LOCAL_TESTING":
                echoer(key, "y")
            case "DOMAIN_NAME_TEST":
                echoer(key, f"'{DOMAIN_NAME_TEST}'")
            case "SMTP_EMAIL_TEST":
                email = os.getenv("EMAIL")
                echoer(key, f"'{email}'")
            case "DJANGO_READ_DOT_ENV_FILE":
                echoer(key, "True")


def _update_static_files(c, settings=None):
    if not settings:
        settings = "config.settings.local"
    c.run(
        f"set -a; source .env; set +a; .venv/bin/python manage.py collectstatic --noinput --settings={settings}"
    )


def _migrate_database(c, settings=None):
    if not settings:
        settings = "config.settings.local"
    c.run(
        f"set -a; source .env; set +a; .venv/bin/python manage.py migrate --noinput --settings={settings}"
    )


@task
def provision_nginx_gunicorn_conf(c, tld=None, sub=None):
    """creates nginx configuration, provide tld and sub domain params to overwrite template"""
    if not _check_if_installed(c):
        _provision_nginx_gunicorn_conf(c, tld, sub)
    else:
        print("nginx already configured!")


def _check_if_installed(c):
    true_ = "Found"
    false_ = "Not Found"

    with c.cd("/etc/nginx/sites-available/"):
        result = c.run(
            f"""[[ -f {c.host} ]] && echo {true_} || echo {false_}"""
        ).stdout.rstrip()
    if result == true_:
        return True
    else:
        return False


def _provision_nginx_gunicorn_conf(c, tld, sub):
    """provision nginx configurations from templates at deploy_tools directory"""
    _check_nginx_gunicorn_installed(c)
    deploy_tools_dir = f"/home/{c.user}/sites/{c.host}/deploy_tools"
    with c.cd(deploy_tools_dir):
        _sed_nginx(c, tld, sub)
        _sed_gunicorn(c)
        start_services(c)


def _check_nginx_gunicorn_installed(c):
    nginx, gunicorn = ("nginx", "gunicorn")
    _check_and_install_package(c, nginx)
    _check_and_install_pip_package(c, gunicorn)


def _sed_nginx(c, tld, sub):
    sudopass = _get_responder()

    if not tld and not sub:
        """testing on an ip address"""

        c.run(
            f'cat nginx.template.conf | sed "s/(DOMAIN.tld|sub.DOMAIN.tld)/{c.host}/g" | sudo tee /etc/nginx/sites-available/{c.host}',
            pty=True,
            watchers=[sudopass],
        )
        c.run(
            f'cat /etc/nginx/sites-available/{c.host} | sed "s/DOMAIN/{c.host}/g" | sudo tee /etc/nginx/sites-available/{c.host}',
            pty=True,
            watchers=[sudopass],
        )
    else:
        c.run(
            f'cat nginx.template.conf | sed "s/DOMAIN/{c.host}/g" | sudo tee /etc/nginx/sites-available/{c.host}',
            pty=True,
            watchers=[sudopass],
        )
        if tld:
            c.run(
                f'cat /etc/nginx/sites-available/{c.host} | sed "s/tld/{tld}/g" | sudo tee /etc/nginx/sites-available/{c.host}',
                pty=True,
                watchers=[sudopass],
            )
        if sub:
            c.run(
                f'cat /etc/nginx/sites-available/{c.host} | sed "s/sub/{sub}/g" | sudo tee /etc/nginx/sites-available/{c.host}',
                pty=True,
                watchers=[sudopass],
            )

        if _check_certbot_file(c, tld):
            crt = f"/etc/letsencrypt/live/{c.host}.{tld}/fullchain.pem"
            c.run(
                f"""cat /etc/nginx/sites-available/{c.host} | sed "s,/etc/nginx/ssl/nginx.crt,{crt},g" | sudo tee /etc/nginx/sites-available/{c.host}""",
                pty=True,
                watchers=[sudopass],
            )
            key = f"/etc/letsencrypt/live/{c.host}.{tld}/privkey.pem"
            c.run(
                f"""cat /etc/nginx/sites-available/{c.host} | sed "s,/etc/nginx/ssl/nginx.key,{key},g" | sudo tee /etc/nginx/sites-available/{c.host}""",
                pty=True,
                watchers=[sudopass],
            )

    c.run(
        f"sudo ln -sf /etc/nginx/sites-available/{c.host} /etc/nginx/sites-enabled/{c.host}",
        pty=True,
        watchers=[sudopass],
    )

    # add nginx to group so that static content is reachable
    c.run(f"sudo usermod -aG {c.user} www-data", pty=True, watchers=[sudopass])


def _check_certbot_file(c, tld):

    result = c.run(
        f'[[ -f /etc/letsencrypt/live/{c.host}.{tld}/fullchain.pem ]] && [[ -f /etc/letsencrypt/live/{c.host}.{tld}/privkey.pem ]] && echo "True" || echo "False"'
    ).stdout.rstrip()
    if result == "True":
        return True
    else:
        return False


def _sed_gunicorn(c):
    """host name in prod will work, but in testing using local or other host name needs to be manually added"""
    sudopass = _get_responder()
    c.run(
        f'cat gunicorn-systemd.template.service | sed "s/DOMAIN/{c.host}/g" | sudo tee /etc/systemd/system/gunicorn-mywebsite.service',
        pty=True,
        watchers=[sudopass],
    )


@task
def start_services(c):
    sudopass = _get_responder()
    c.run("sudo systemctl daemon-reload", pty=True, watchers=[sudopass])
    c.run("sudo systemctl reload nginx", pty=True, watchers=[sudopass])
    c.run(
        f"sudo systemctl enable gunicorn-mywebsite",
        pty=True,
        watchers=[sudopass],
    )
    c.run(
        f"sudo systemctl start gunicorn-mywebsite",
        pty=True,
        watchers=[sudopass],
    )


@task
def restart_gunicorn(c):
    sudopass = _get_responder()
    c.run(
        f"sudo systemctl restart gunicorn-systemd.test-server.service",
        pty=True,
        watchers=[sudopass],
    )


@task
def full_restart(c):
    sudopass = _get_responder
    c.run("sudo systemctl daemon-reload", pty=True, watchers=[sudopass])
    c.run("sudo systemctl reload nginx", pty=True, watchers=[sudopass])
    restart_gunicorn(c)


@task
def provision_database(c):
    _set_needrestart_auto(c)
    _check_postgres_installed(c)
    sudopass = _get_responder()
    user = os.environ.get("DB_USER")

    check_user_exists = f""" if [ "$(psql postgres -XtAc "select 1 from pg_roles where rolname='{user}'")" = '1' ]; then
            echo "User: {user} exists!"
        else
            echo "User: {user} does not exist...creating user"
            sudo -u postgres psql -c "create user {user} with password '{os.environ.get('DB_PASS')}';"
            sudo -u postgres psql -c "alter user {user} createdb;"
        fi
    """
    c.run(check_user_exists, pty=True, watchers=[sudopass])

    databse_setup = f""" if [ "$(psql postgres -XtAc "select 1 from pg_database where datname='{DB_NAME}'")" = '1' ]; then
            echo "database already exists!"
        else
            echo "database does not exist... creating database"
            sudo -u postgres psql -c "create database {DB_NAME};"
        fi
        
        echo "giving privileges to user: {user}"
        sudo -u postgres psql -c "grant all privileges on database {DB_NAME} to {user};"
    """
    c.run(databse_setup, pty=True, watchers=[sudopass])

    set_postgres_pass = f""" sudo -u postgres psql -c "alter user postgres with password '{os.environ.get('DB_PASS')}';" """
    c.run(set_postgres_pass, pty=True, watchers=[sudopass])


def _set_needrestart_auto(c):
    """this is to auto accept daemon gui restart prompts during installation of certain pacakges"""
    sudopass = _get_responder()
    with c.cd(f"/etc/needrestart/"):
        if c.run("test -f needrestart.conf.bak", warn=True).failed:
            # create backup of needrestart.conf
            c.run(
                "sudo cp needrestart.conf needrestart.conf.bak",
                pty=True,
                watchers=[sudopass],
            )
        # replaces nrconf{restart} = 'i' with nrconf{restart} = 'a'
        c.run(
            "sudo sed -i \"s/#\$nrconf{restart} = 'i'/\$nrconf{restart} = 'a'/g\" needrestart.conf",
            pty=True,
            watchers=[sudopass],
        )


def _check_postgres_installed(c):
    sudopass = _get_responder()
    check_postgres = f""" if [ "$(which psql)" = "" ]; then
        sudo apt-get install postgresql -y;
    else
        echo "postgresql already installed!"
    fi
    """
    c.run(check_postgres, pty=True, watchers=[sudopass])


def _get_responder():
    """generic Responder object"""
    passwd = os.environ.get("REMOTE_PASSW")
    return Responder(pattern=r"\[sudo\] password[a-z|\s]*:", response=passwd + "\n")


def _check_packages_and_install(c, packages):
    for package in packages:
        _check_and_install_package(package=package)


def _check_and_install_package(c, package):
    sudopass = _get_responder()
    result = c.run(f"""echo $(dpkg-query -W -f='${{Status}}' {package} 2>/dev/null)""")
    result = result.stdout.rstrip()
    expected = "install ok installed"
    if not result in expected or result in "":
        # package not installed
        c.run(f"sudo apt install {package} -y", pty=True, watchers=[sudopass])


def _install_package(c, package):
    sudopass = _get_responder()
    c.run(f"sudo apt install {package} -y", pty=True, watchers=[sudopass])


def _check_and_install_pip_package(c, pip_package):
    """check for pip pacakges in venv directory"""
    venv_dir = _get_site_folder(user=c.user, host=c.host) + ".venv/bin/"
    result = c.run(f"{venv_dir}pip freeze | grep '{pip_package}'")
    if not pip_package in result.stdout:
        c.run(f"{venv_dir}pip install {pip_package}")


def _check_pip_package(c, pip_package):
    """returns a Result object"""
    return c.run(f"pip freeze | grep '{pip_package}'")


@task
def copy_install_packages_to_host(c):
    keyname = os.environ.get("AGENT_KEYNAME")
    server_user_name = os.environ.get("SERVER_USER_NAME")
    ip = os.environ.get("HOST_IP")
    install_packages_loc = "~/install_packages.sh"
    result = c.run(
        f"""scp -i ~/.ssh/{keyname} {install_packages_loc} {server_user_name}@{ip}:/home/{server_user_name}/"""
    )


@task
def setup_database(c):
    _set_needrestart_auto(c)
    user = os.environ.get("DB_USERNAME")
    db_pass = os.environ.get("DB_USER_PASS")
    db_name = os.environ.get("DB_NAME")
    sudopass = _get_responder()
    # create base user
    c.run(
        f"""
        if [ $(psql postgres -tXAc "SELECT 1 FROM pg_roles WHERE rolname='{user}';") -eq 1 ];then
            echo user already exists! continuing...
        else
            sudo -u postgres psql -c "create user {user} with password '{db_pass}';" 
        fi
        """,
        pty=True,
        watchers=[sudopass],
    )
    # create db
    c.run(
        f"""
            if [[ -z 'psql -Atqc "\list {db_name}" postgres' ]];then
                sudo -u postgres createdb {db_name}
            else
                echo db already exists! continuing...
            fi
          """,
        pty=True,
        watchers=[sudopass],
    )

    # alter roles
    c.run(
        f"""sudo -u postgres psql -c "alter role postgres with password '{db_pass}';" """,
        pty=True,
        watchers=[sudopass],
    )

    c.run(
        f"""sudo -u postgres psql -c "grant all privileges on database {db_name} to {user};" """,
        pty=True,
        watchers=[sudopass],
    )

    c.run(
        f"""sudo -u postgres psql -c "grant all privileges on database {db_name} to postgres;" """,
        pty=True,
        watchers=[sudopass],
    )


@task
def install_packages(c):
    filename = "install_packages.sh"
    sudopass = _get_responder()

    c.run(f"source {filename}", pty=True, watchers=[sudopass])


@task
def install_node_tools(c):
    filename = "check_node_tools.sh"
    sudopass = _get_responder()

    c.run(f"source {filename}", pty=True, watchers=[sudopass])