#!/usr/bin/env python3

import adx
import argparse
import diva
import os
import sys
import utage
import db
import xdudata

LANGUAGES = ["jpn", "eng", "rus"]


def main():
    parser = argparse.ArgumentParser(description="Unpack and process XDU data")

    global_flag_parser = argparse.ArgumentParser(add_help=False)
    global_flag_parser.add_argument(
        "-g",
        "--global",
        help="Whether we are running on Global XDU.",
        action="store_true",
        dest="is_global",
        default=False,
    )

    subparsers = parser.add_subparsers(
        metavar="<command>", title="subcommands", dest="command"
    )

    # adx subcommand
    parser_adx = subparsers.add_parser("adx", help="ADX stuff")
    parser_adx_subparsers = parser_adx.add_subparsers(
        metavar="<command>", title="subcommands", dest="subcommand"
    )
    # adx loop
    parser_adx_loop = parser_adx_subparsers.add_parser("loop", help="Extract loop data")
    parser_adx_loop.add_argument(
        "--output",
        "-o",
        help="JSON output file for loop data",
        type=str,
        dest="JSON_OUT",
    )
    parser_adx_loop.add_argument(
        "ADX_DIR", help="Input directory containing ADX files", type=str
    )

    # utage subcommand
    parser_utage = subparsers.add_parser("utage", help="UTAGE stuff")
    parser_utage_subparsers = parser_utage.add_subparsers(
        metavar="<command>", title="subcommand", dest="subcommand"
    )
    # utage crypt
    parser_utage_crypt = parser_utage_subparsers.add_parser(
        "crypt", help="Encrypt/decrypt utage tsv files"
    )
    parser_utage_crypt.add_argument(
        "--encrypt",
        "-e",
        help="Encrypt (default: Decrypt)",
        dest="encrypt",
        action="store_true",
        default=False,
    )
    parser_utage_crypt.add_argument(
        "--no-compression",
        "-n",
        help="Do not compress/decompress. Only applies to tsv, png will never be compressed",
        dest="ncomp",
        action="store_true",
        default=False,
    )
    parser_utage_crypt.add_argument(
        "--key",
        "-k",
        help="Encryption key (Default: SampleSecretKey)",
        dest="key",
        type=str,
        default="SampleSecretKey",
    )
    parser_utage_crypt.add_argument(
        "--hex",
        "-x",
        help="KEY is hexadecimal (Default: False)",
        dest="hex",
        action="store_true",
        default=False,
    )
    parser_utage_crypt.add_argument("TARGET", help="Input", type=str)
    # utage translate
    parser_utage_translate = parser_utage_subparsers.add_parser(
        "translate",
        help="Generate keyed tsv and json files",
        parents=[global_flag_parser],
    )
    parser_utage_translate.add_argument("INPUT", help="Input", type=str)
    parser_utage_translate.add_argument(
        "TSVDIR", nargs="?", help="_t.tsv output directory", type=str, default="."
    )
    parser_utage_translate.add_argument(
        "JSONDIR", nargs="?", help="json output directory", type=str, default="."
    )
    # utage names
    parser_utage_names = parser_utage_subparsers.add_parser(
        "names", help="Generate and update name files", parents=[global_flag_parser]
    )
    parser_utage_names.add_argument("INPUT", help="Input", type=str)
    parser_utage_names.add_argument(
        "OLD", nargs="?", help="Directory with old files", type=str, default="."
    )

    # diva subcommand
    parser_diva = subparsers.add_parser("diva", help="Diva stuff")
    parser_diva_subparsers = parser_diva.add_subparsers(
        metavar="<command>", title="subcommand", dest="subcommand"
    )
    parser_diva_quest = parser_diva_subparsers.add_parser(
        "quest", help="Generate quest JSON files", parents=[global_flag_parser],
    )
    parser_diva_quest.add_argument(
        "INPUT",
        help="Directory of databases containing Quest*.db and ResourceEntry.db",
        type=str,
    )
    parser_diva_quest.add_argument(
        "--utage", help="Directory of Utage folders and files.", type=str, default=None,
    )
    parser_diva_quest.add_argument(
        "OLD", help="Directory with old quest files", nargs="?", type=str, default="."
    )

    # xdudata command
    parser_xdudata = subparsers.add_parser(
        "xdudata", help="XduPlayer Generation Automation"
    )
    parser_xdudata_subparsers = parser_xdudata.add_subparsers(
        metavar="<command>", title="subcommand", dest="subcommand"
    )
    parser_xdudata_update = parser_xdudata_subparsers.add_parser(
        "update", help="Update an XDUData directory"
    )
    parser_xdudata_update.add_argument(
        "CACHE", help="files/ directory from XDU cache", type=str
    )
    parser_xdudata_update.add_argument("XDUDATA", help="old XDUData folder", type=str)
    parser_xdudata_update.add_argument("TRANS", help="xdutranslations.git", type=str)
    parser_xdudata_update.add_argument("EXTRACT", help="AV extraction folder", type=str)

    args = parser.parse_args()

    if args.command == "adx":
        if args.subcommand == "loop":
            adx.extract_loop_data_from_dir(args.ADX_DIR, args.JSON_OUT)
    elif args.command == "utage":
        if args.subcommand == "crypt":
            if not args.hex:
                key = bytearray(args.key, "utf-8")
            else:
                key = bytearray.fromhex(args.key)
            if os.path.isfile(args.TARGET):
                utage.crypt.crypt_file(args.TARGET, key, args.encrypt, args.ncomp)
            elif os.path.isdir(args.TARGET):
                utage.crypt.crypt_dir(args.TARGET, key, args.encrypt, args.ncomp)
            else:
                raise FileNotFoundError("Could not find {}".format(args.TARGET))
        elif args.subcommand == "translate":
            if os.path.isfile(args.INPUT):
                utage.translate.translate_file(
                    args.INPUT, args.TSVDIR, args.JSONDIR, args.is_global
                )
            elif os.path.isdir(args.INPUT):
                utage.translate.translate_dir(
                    args.INPUT, args.TSVDIR, args.JSONDIR, args.is_global
                )
            else:
                raise FileNotFoundError("Could not find {}".format(args.INPUT))
        elif args.subcommand == "names":
            if os.path.isdir(args.INPUT):
                utage.names.update_names(
                    args.INPUT, args.OLD, LANGUAGES, args.is_global
                )
            else:
                raise FileNotFoundError(args.INPUT)
    elif args.command == "diva":
        if args.subcommand == "quest":
            if not args.utage:
                diva.quest.update_missions(
                    args.INPUT, args.OLD, LANGUAGES, args.is_global
                )
            else:
                diva.quest.update_missions(
                    args.INPUT, args.OLD, LANGUAGES, args.is_global, utage_in=args.utage
                )
    elif args.command == "xdudata":
        if args.subcommand == "update":
            # add the tools folder to PATH
            os.environ["PATH"] += os.pathsep + os.path.join(
                os.path.abspath(os.path.dirname(__file__)), "tools"
            )

            # update the data
            xdudata.update_all(
                args.CACHE, args.XDUDATA, args.TRANS, args.EXTRACT, LANGUAGES,
            )

    return 0


if __name__ == "__main__":
    main()
    sys.exit()