#!/usr/bin/env python3

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

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


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

    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"
    )
    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"
    )
    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"
    )
    parser_diva_quest.add_argument(
        "INPUT",
        help="Directory of databases containing Quest*.db and ResourceEntry.db",
        type=str,
    )
    parser_diva_quest.add_argument(
        "OLD", help="Directory with old quest files", nargs="?", type=str, default="."
    )

    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)
            elif os.path.isdir(args.INPUT):
                utage.translate.translate_dir(args.INPUT, args.TSVDIR, args.JSONDIR)
            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)
            else:
                raise FileNotFoundError(args.INPUT)
    elif args.command == "diva":
        if args.subcommand == "quest":
            diva.quest.update_missions(args.INPUT, args.OLD, LANGUAGES)

    return 0


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