"""
SporeStack CLI: `sporestack`
"""

import json
import logging
import os
import time
from pathlib import Path
from typing import Any, Dict, Optional

import typer

HELP = """
SporeStack Python CLI

Optional environment variables:
SPORESTACK_ENDPOINT
*or*
SPORESTACK_USE_TOR_ENDPOINT

TOR_PROXY (defaults to socks5h://127.0.0.1:9050 which is fine for most)
"""

_home = os.getenv("HOME", None)
assert _home is not None, "Unable to detect $HOME environment variable?"
HOME = Path(_home)

SPORESTACK_DIR = HOME / ".sporestack"

# Try to protect files in ~/.sporestack
os.umask(0o0077)

cli = typer.Typer(help=HELP)

HOME = Path(_home)

token_cli = typer.Typer(help="Commands to interact with SporeStack tokens")
cli.add_typer(token_cli, name="token")
server_cli = typer.Typer(help="Commands to interact with SporeStack servers")
cli.add_typer(server_cli, name="server")

logging.basicConfig(level=logging.INFO)

DEFAULT_TOKEN = "primary"
DEFAULT_FLAVOR = "vps-1vcpu-1gb"
# Users may have a different key file, but this is the most common.
DEFAULT_SSH_KEY_FILE = HOME / ".ssh" / "id_rsa.pub"

# On disk format
TOKEN_VERSION = 1

WAITING_PAYMENT_TO_PROCESS = "Waiting for payment to process..."


def get_api_endpoint() -> str:
    from .api_client import CLEARNET_ENDPOINT, TOR_ENDPOINT

    api_endpoint = os.getenv("SPORESTACK_ENDPOINT", CLEARNET_ENDPOINT)
    if os.getenv("SPORESTACK_USE_TOR_ENDPOINT", None) is not None:
        api_endpoint = TOR_ENDPOINT
    return api_endpoint


def make_payment(currency: str, uri: str, usd: str) -> None:
    import segno

    premessage = """Payment URI: {}
Pay *exactly* the specified amount. No more, no less. Pay within
one hour at the very most.
Resize your terminal and try again if QR code above is not readable.
Press ctrl+c to abort."""
    message = premessage.format(uri)
    qr = segno.make(uri)
    # This typer.echos.
    qr.terminal()
    typer.echo(message)
    typer.echo(f"Approximate price in USD: {usd}")
    input("[Press enter once you have made payment.]")


@server_cli.command()
def launch(
    hostname: str = "",
    days: int = typer.Option(...),
    operating_system: str = typer.Option(...),
    ssh_key_file: Path = DEFAULT_SSH_KEY_FILE,
    flavor: str = DEFAULT_FLAVOR,
    token: str = DEFAULT_TOKEN,
    region: Optional[str] = None,
    quote: bool = typer.Option(True, help="Require manual price confirmation."),
    autorenew: bool = typer.Option(False, help="BETA: Automatically renew server."),
) -> None:
    """
    Launch a server on SporeStack.
    """
    typer.echo(f"Launching server with token {token}...", err=True)
    _token = load_token(token)

    from . import utils
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    typer.echo(f"Loading SSH key from {ssh_key_file}...")
    if not ssh_key_file.exists():
        msg = f"{ssh_key_file} does not exist. "
        msg += "You can try generating a key file with `ssh-keygen`"
        typer.echo(msg, err=True)
        raise typer.Exit(code=1)

    ssh_key = ssh_key_file.read_text()

    machine_id = utils.random_machine_id()

    if quote:
        response = api_client.server_launch(
            machine_id=machine_id,
            days=days,
            flavor=flavor,
            operating_system=operating_system,
            ssh_key=ssh_key,
            region=region,
            token=_token,
            quote=True,
            hostname=hostname,
            autorenew=autorenew,
        )

        msg = f"Is {response.payment.usd} for {days} day(s) of {flavor} okay?"
        typer.echo(msg, err=True)
        input("[Press ctrl+c to cancel, or enter to accept.]")

    if autorenew:
        typer.echo(
            "Server will be automatically renewed (from this token) to one week of expiration.",  # noqa: E501
            err=True,
        )
        typer.echo(
            "If using this feature, watch your token balance and server expiration closely!",  # noqa: E501
            err=True,
        )

    tries = 360
    while tries > 0:
        response = api_client.server_launch(
            machine_id=machine_id,
            days=days,
            flavor=flavor,
            operating_system=operating_system,
            ssh_key=ssh_key,
            region=region,
            token=_token,
            hostname=hostname,
            autorenew=autorenew,
        )
        if response.created is True:
            break
        typer.echo("Waiting for server to build...", err=True)
        tries = tries + 1
        # Waiting for server to spin up.
        time.sleep(10)

    if response.created is False:
        typer.echo("Server creation failed, tries exceeded.", err=True)
        raise typer.Exit(code=1)

    typer.echo(
        pretty_machine_info(api_client.server_info(machine_id=machine_id).dict())
    )


@server_cli.command()
def topup(
    hostname: str = "",
    machine_id: str = "",
    days: int = typer.Option(...),
    token: str = DEFAULT_TOKEN,
) -> None:
    """
    Extend an existing SporeStack server's lifetime.
    """

    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)

    _token = load_token(token)

    api_client.server_topup(
        machine_id=machine_id,
        days=days,
        token=_token,
    )

    typer.echo(f"Server topped up for {days} day(s)")


def server_info_path() -> Path:
    # Put servers in a subdirectory
    servers_dir = SPORESTACK_DIR / "servers"

    # Migrate existing server.json files into servers subdirectory
    if SPORESTACK_DIR.exists() and not servers_dir.exists():
        typer.echo(
            f"Migrating server profiles found in {SPORESTACK_DIR} to {servers_dir}.",
            err=True,
        )
        servers_dir.mkdir()
        for json_file in SPORESTACK_DIR.glob("*.json"):
            json_file.rename(servers_dir / json_file.name)

    # Make it, if it doesn't exist already.
    SPORESTACK_DIR.mkdir(exist_ok=True)
    servers_dir.mkdir(exist_ok=True)

    return servers_dir


def token_path() -> Path:
    token_dir = SPORESTACK_DIR / "tokens"

    # Make it, if it doesn't exist already.
    token_dir.mkdir(exist_ok=True, parents=True)

    return token_dir


def get_machine_info(hostname: str) -> Dict[str, Any]:
    """
    Get info from disk.
    """
    directory = server_info_path()
    json_file = directory / f"{hostname}.json"
    if not json_file.exists():
        raise ValueError(f"{hostname} does not exist in {directory} as {json_file}")
    machine_info = json.loads(json_file.read_bytes())
    assert isinstance(machine_info, dict)
    if machine_info["vm_hostname"] != hostname:
        raise ValueError("hostname does not match filename.")
    return machine_info


def pretty_machine_info(info: Dict[str, Any]) -> str:
    msg = "Machine ID (keep this secret!): {}\n".format(info["machine_id"])
    if "vm_hostname" in info:
        msg += "Hostname: {}\n".format(info["vm_hostname"])
    elif "hostname" in info:
        msg += "Hostname: {}\n".format(info["hostname"])

    if "network_interfaces" in info:
        if "ipv6" in info["network_interfaces"][0]:
            msg += "IPv6: {}\n".format(info["network_interfaces"][0]["ipv6"])
        if "ipv4" in info["network_interfaces"][0]:
            msg += "IPv4: {}\n".format(info["network_interfaces"][0]["ipv4"])
    else:
        if "ipv6" in info:
            msg += "IPv6: {}\n".format(info["ipv6"])
        if "ipv4" in info:
            msg += "IPv4: {}\n".format(info["ipv4"])
    expiration = info["expiration"]
    human_expiration = time.strftime("%Y-%m-%d %H:%M:%S %z", time.localtime(expiration))
    if "running" in info:
        msg += "Running: {}\n".format(info["running"])
    msg += f"Expiration: {expiration} ({human_expiration})\n"
    time_to_live = expiration - int(time.time())
    hours = time_to_live // 3600
    msg += f"Server will be deleted in {hours} hours."
    return msg


@server_cli.command(name="list")
def server_list(
    token: str = DEFAULT_TOKEN,
    local: bool = typer.Option(
        True, help="List older servers not associated to token."
    ),
) -> None:
    """
    List all locally known servers and all servers under the given token.
    """
    from .api_client import APIClient
    from .exceptions import SporeStackUserError

    api_client = APIClient(api_endpoint=get_api_endpoint())

    _token = load_token(token)

    server_infos = api_client.servers_launched_from_token(token=_token).servers
    machine_id_hostnames = {}

    if local:
        directory = server_info_path()
        for hostname_json in os.listdir(directory):
            hostname = hostname_json.split(".")[0]
            saved_vm_info = get_machine_info(hostname)
            machine_id_hostnames[saved_vm_info["machine_id"]] = hostname

    printed_machine_ids = []

    for info in server_infos:
        typer.echo()

        hostname = info.hostname
        if hostname == "":
            if info.machine_id in machine_id_hostnames:
                hostname = machine_id_hostnames[info.machine_id]
        if hostname != "":
            typer.echo(f"Hostname: {hostname}")

        typer.echo(f"Machine ID (keep this secret!): {info.machine_id}")
        typer.echo(f"IPv6: {info.network_interfaces[0].ipv6}")
        typer.echo(f"IPv4: {info.network_interfaces[0].ipv4}")
        typer.echo(f"Region: {info.region}")
        typer.echo(f"Flavor: {info.flavor.slug}")
        human_expiration = time.strftime(
            "%Y-%m-%d %H:%M:%S %z", time.localtime(info.expiration)
        )
        typer.echo(f"Expiration: {info.expiration} ({human_expiration})")
        typer.echo(f"Token: {info.token}")
        if info.deleted:
            typer.echo("Server was deleted!")
        else:
            typer.echo(f"Running: {info.running}")
            time_to_live = info.expiration - int(time.time())
            hours = time_to_live // 3600
            typer.echo(f"Server will be deleted in {hours} hours.")
            typer.echo(f"Autorenew: {info.autorenew}")

        printed_machine_ids.append(info.machine_id)

    if local:
        for hostname_json in os.listdir(directory):
            hostname = hostname_json.split(".")[0]
            saved_vm_info = get_machine_info(hostname)
            machine_id = saved_vm_info["machine_id"]
            if machine_id in printed_machine_ids:
                continue

            try:
                upstream_vm_info = api_client.server_info(
                    machine_id=saved_vm_info["machine_id"]
                )
                saved_vm_info["expiration"] = upstream_vm_info.expiration
                saved_vm_info["running"] = upstream_vm_info.running
                typer.echo()
                typer.echo(pretty_machine_info(saved_vm_info))
            except SporeStackUserError as e:
                expiration = saved_vm_info["expiration"]
                human_expiration = time.strftime(
                    "%Y-%m-%d %H:%M:%S %z", time.localtime(expiration)
                )
                msg = hostname
                msg += f" expired ({expiration} {human_expiration}): "
                msg += str(e)
                typer.echo(msg)

    typer.echo()


def _get_machine_id(machine_id: str, hostname: str, token: str) -> str:
    usage = "--hostname *OR* --machine-id must be set."

    if machine_id != "" and hostname != "":
        typer.echo(usage, err=True)
        raise typer.Exit(code=2)

    if machine_id != "":
        return machine_id

    if hostname == "":
        typer.echo(usage, err=True)
        raise typer.Exit(code=2)

    try:
        machine_id = get_machine_info(hostname)["machine_id"]
        assert isinstance(machine_id, str)
        return machine_id
    except Exception:
        pass

    _token = load_token(token)

    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    for server in api_client.servers_launched_from_token(token=_token).servers:
        if server.hostname == hostname:
            return server.machine_id

    typer.echo(
        f"Could not find any servers matching the hostname: {hostname}", err=True
    )
    raise typer.Exit(code=1)


@server_cli.command()
def info(hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN) -> None:
    """
    Info on the VM
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    typer.echo(
        pretty_machine_info(api_client.server_info(machine_id=machine_id).dict())
    )


@server_cli.command(name="json")
def server_info_json(
    hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN
) -> None:
    """
    Info on the VM, in JSON format
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    typer.echo(api_client.server_info(machine_id=machine_id).json())


@server_cli.command()
def start(hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN) -> None:
    """
    Boots the VM.
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.server_start(machine_id=machine_id)
    typer.echo(f"{hostname} started.")


@server_cli.command()
def stop(hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN) -> None:
    """
    Immediately shuts down the VM.
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.server_stop(machine_id=machine_id)
    typer.echo(f"{hostname} stopped.")


@server_cli.command()
def autorenew_enable(
    hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN
) -> None:
    """
    Enable autorenew on a server.
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.autorenew_enable(machine_id=machine_id)
    typer.echo("Autorenew enabled.")


@server_cli.command()
def autorenew_disable(
    hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN
) -> None:
    """
    Disable autorenew on a server.
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.autorenew_disable(machine_id=machine_id)
    typer.echo("Autorenew disabled.")


@server_cli.command()
def delete(
    hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN
) -> None:
    """
    Delete the VM before its expiration
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.server_delete(machine_id=machine_id)
    # Also remove the .json file
    server_info_path().joinpath(f"{hostname}.json").unlink(missing_ok=True)
    typer.echo(f"{machine_id} was destroyed.")


@server_cli.command()
def forget(
    hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN
) -> None:
    """
    Forget about a deleted server so that it doesn't show up in server list.
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.server_forget(machine_id=machine_id)
    typer.echo(f"{machine_id} was forgotten.")


@server_cli.command()
def rebuild(
    hostname: str = "", machine_id: str = "", token: str = DEFAULT_TOKEN
) -> None:
    """
    Rebuilds the VM with the operating system and SSH key given at launch time.

    Will take a couple minutes to complete after the request is made.
    """
    machine_id = _get_machine_id(machine_id=machine_id, hostname=hostname, token=token)
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    api_client.server_rebuild(machine_id=machine_id)
    typer.echo(f"{hostname} rebuilding.")


@server_cli.command()
def flavors() -> None:
    """
    Returns available flavors.
    """
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    flavors = api_client.flavors().flavors
    for flavor in flavors:
        typer.echo(f"{flavor}: {flavors[flavor]}")


@server_cli.command()
def operating_systems() -> None:
    """
    Returns available operating systems.
    """
    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())
    os_list = api_client.operating_systems().operating_systems
    for operating_system in os_list:
        typer.echo(operating_system)


def load_token(token: str) -> str:
    token_file = token_path().joinpath(f"{token}.json")
    if not token_file.exists():
        msg = f"Token '{token}' ({token_file}) does not exist. Create it with:\n"
        msg += f"sporestack token create {token} --dollars 20 --currency xmr\n"
        msg += "(Can do more than $20, or a different currency, like btc.)\n"
        msg += (
            "With the token credited, you can launch servers, renew existing ones, etc."
        )
        typer.echo(msg, err=True)
        raise typer.Exit(code=1)

    token_data = json.loads(token_file.read_text())
    assert token_data["version"] == 1
    assert isinstance(token_data["key"], str)
    return token_data["key"]


def save_token(token: str, key: str) -> None:
    token_file = token_path().joinpath(f"{token}.json")
    if token_file.exists():
        msg = f"Token '{token}' already exists in {token_file}. Aborting!"
        typer.echo(msg, err=True)
        raise typer.Exit(code=1)

    token_data = {"version": TOKEN_VERSION, "name": token, "key": key}
    token_file.write_text(json.dumps(token_data))


@token_cli.command(name="create")
def token_create(
    token: str = typer.Argument(DEFAULT_TOKEN),
    dollars: int = typer.Option(...),
    currency: str = typer.Option(...),
) -> None:
    """
    Enables a new settlement token.

    Dollars is starting balance.
    """
    from . import utils

    _token = utils.random_token()

    typer.echo(f"Generated key {_token} for use with token {token}", err=True)

    if Path(SPORESTACK_DIR / "tokens" / f"{token}.json").exists():
        typer.echo("Token already created! Did you mean to `topup`?", err=True)
        raise typer.Exit(1)

    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    response = api_client.token_add(
        token=_token,
        dollars=dollars,
        currency=currency,
        retry=True,
    )

    uri = response.payment.uri
    assert uri is not None
    usd = response.payment.usd

    make_payment(currency=currency, uri=uri, usd=usd)

    tries = 360 * 2
    while tries > 0:
        typer.echo(WAITING_PAYMENT_TO_PROCESS, err=True)
        tries = tries - 1
        # FIXME: Wait two hours in a smarter way.
        # Waiting for payment to set in.
        time.sleep(10)
        response = api_client.token_add(
            token=_token,
            dollars=dollars,
            currency=currency,
            retry=True,
        )
        if response.payment.paid is True:
            typer.echo(f"{token} has been enabled with ${dollars}.")
            typer.echo(f"{token}'s key is {_token}.")
            typer.echo("Save it, don't share it, and don't lose it!")
            save_token(token, _token)
            return
    raise ValueError(f"{token} did not get enabled in time.")


@token_cli.command(name="import")
def token_import(
    name: str = typer.Argument(DEFAULT_TOKEN),
    key: str = typer.Option(...),
) -> None:
    """
    Imports a token from a key.
    """
    save_token(name, key)


@token_cli.command(name="topup")
def token_topup(
    token: str = typer.Argument(DEFAULT_TOKEN),
    dollars: int = typer.Option(...),
    currency: str = typer.Option(...),
) -> None:
    """
    Adds balance to an existing settlement token.
    """
    token = load_token(token)

    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    response = api_client.token_add(
        token,
        dollars,
        currency=currency,
        retry=True,
    )

    uri = response.payment.uri
    assert uri is not None
    usd = response.payment.usd

    make_payment(currency=currency, uri=uri, usd=usd)

    tries = 360 * 2
    while tries > 0:
        typer.echo(WAITING_PAYMENT_TO_PROCESS, err=True)
        tries = tries - 1
        # FIXME: Wait two hours in a smarter way.
        response = api_client.token_add(
            token,
            dollars,
            currency=currency,
            retry=True,
        )
        # Waiting for payment to set in.
        time.sleep(10)
        if response.payment.paid is True:
            typer.echo(f"Added {dollars} dollars to {token}")
            return
    raise ValueError(f"{token} did not get enabled in time.")


@token_cli.command()
def balance(token: str = typer.Argument(DEFAULT_TOKEN)) -> None:
    """
    Gets balance for a settlement token.
    """
    _token = load_token(token)

    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    typer.echo(api_client.token_balance(token=_token).usd)


@token_cli.command()
def servers(token: str = typer.Argument(DEFAULT_TOKEN)) -> None:
    """
    Returns server info for servers launched by a given token.
    """
    _token = load_token(token)

    from .api_client import APIClient

    api_client = APIClient(api_endpoint=get_api_endpoint())

    typer.echo(api_client.servers_launched_from_token(token=_token))


@token_cli.command(name="list")
def token_list() -> None:
    """
    Gets balance for a settlement token.
    """
    token_dir = token_path()
    typer.echo(f"SporeStack tokens present in {token_dir}:", err=True)
    typer.echo("(Name): (Key)", err=True)
    for token_file in token_dir.glob("*.json"):
        token = token_file.stem
        key = load_token(token)
        typer.echo(f"{token}: {key}")


@cli.command()
def version() -> None:
    """
    Returns the installed version.
    """
    from . import __version__

    typer.echo(__version__)


@cli.command()
def api_endpoint() -> None:
    """
    Prints the selected API endpoint: Env var: SPORESTACK_ENDPOINT,
    or, SPORESTACK_USE_TOR=1
    """
    from . import api_client

    endpoint = get_api_endpoint()
    if ".onion" in endpoint:
        typer.echo(f"{endpoint} using {api_client._get_tor_proxy()}")
        return
    else:
        typer.echo(endpoint)
        return


if __name__ == "__main__":
    cli()