import argparse
import asyncio
import os
from . import client, sys_service, user_service
from .sys_service import rpc
from .user_service import rpc
del rpc


def main(args):
    # Parser
    parser = argparse.ArgumentParser("home-backup", description="Manage backup tools")
    sub_parser = parser.add_subparsers(dest="action")

    parser_backup_add = sub_parser.add_parser("backup-add", help="Add backup.")
    parser_backup_add.add_argument("--type", nargs="?", type=str, default="borgbackup", help="The backup type.\nDefault: borgbackup")
    parser_backup_add.add_argument("--remote", nargs="?", type=str, default=None, help="The remote of the backup (required by borgbackup).")
    parser_backup_add.add_argument("name", nargs=1, type=str, help="The name of the backup.")
    parser_backup_list = sub_parser.add_parser("backup-list", help="List all backups.")
    parser_backup_delete = sub_parser.add_parser("backup-delete", help="Delete a backup.")

    parser_remote_add = sub_parser.add_parser("remote-add", help="Add remote for backups.")
    parser_remote_add.add_argument("--type", nargs="?", type=str, default="borgbackup", help="The remote type.\nDefault: borgbackup")
    parser_remote_add.add_argument("--target", nargs="?", type=str, default=None, help="The target of the remote (required by borgbackup).")
    parser_remote_add.add_argument("name", nargs=1, type=str, help="The name of the remote.")
    parser_remote_list = sub_parser.add_parser("remote-list", help="List remotes.")
    parser_remote_list.add_argument("name", nargs="?", type=str, default=None, help="Name of the backup to show details.")
    parser_remote_delete = sub_parser.add_parser("remote-delete", help="Delete remote.")
    parser_remote_delete.add_argument("name", nargs="+", type=str, help="The name of the remote to remove.")

    parser_system_server = sub_parser.add_parser("system-server", help="Run system service (root required).")
    parser_system_server.add_argument("--fork", action="store_const", const=True, default=False, help="Makes a deamon through forking.")
    parser_user_server = sub_parser.add_parser("user-server", help="Run user service.")
    parser_user_server.add_argument("--fork", action="store_const", const=True, default=False, help="Makes a deamon through forking.")

    # Arguments
    result = parser.parse_args(args)

    # Deamon mode
    if result.action == "system-server":
        # Checks
        if os.getuid() != 0:  # Check root
            raise RuntimeError("System service has to run as root.")

        # Run deamon
        if result.fork:
            if os.fork() != 0:
                return  # Stop as parent process
        asyncio.run(sys_service.rpc.run_deamon(fork=result.fork))  # TODO: Change default path
    elif result.action == "user-server":
        asyncio.run(user_service.rpc.run_deamon(fork=result.fork))  # TODO: Change default path of user and system socket

    # Backup
    if result.action == "backup-add":
        # Check backup type
        backup_type = result.type
        if backup_type not in ("borgbackup",):
            raise ValueError("Unknown backup type %s." & repr(backup_type))

        # Parse type
        info = {}
        if backup_type == "borgbackup":
            if result.remote is None:
                raise ValueError("Remote is required for borg backup.")
            info["remote"] = result.remote
        else:
            raise NotImplementedError("Type %s isn't supported well." % repr(backup_type))

        # Add backup
        client.run_command(client.backup_add_gen(name=result.name[0], btype=backup_type, info=info))

    # Remote
    elif result.action == "remote-add":
        # Check remote type
        remote_type = result.type
        if remote_type not in ("borgbackup",):
            raise ValueError("Unknown backup type %s." % repr(remote_type))

        # Parse type
        info = {}
        if remote_type == "borgbackup":
            if result.target is None:
                raise ValueError("Target isn't set.")
            info["target"] = result.target
        else:
            raise NotImplementedError("Type %s isn't supported well." % remote_type)

        # Add remote
        client.run_command(client.remote_add_gen(name=result.name[0], rtype=remote_type, info=info))
    elif result.action == "remote-list":
        client.run_command(client.remote_list_gen(name=result.name))
    elif result.action == "remote-delete":
        client.run_command(client.remote_delete_gen(result.name))

    # Not found action
    elif result.action is None:
        parser.parse_args(["--help"])
    else:
        raise NotImplementedError("Action %s isn't implemented." % result.action)


if __name__ == "__main__":
    import sys
    main(sys.argv[1:])