import sys
import typing
import argparse

from turbo_turtle import __version__
from turbo_turtle import _settings
from turbo_turtle import _docs
from turbo_turtle import _utilities
from turbo_turtle import _fetch
from turbo_turtle import geometry_xyplot
from turbo_turtle._abaqus_python.turbo_turtle_abaqus import parsers


def _print_abaqus_path_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(add_help=False)
    # This parser has no arguments. Current implementation acts like a flag
    return parser



[docs]
def _print_abaqus_path_location() -> None:
    """Print the absolute path to the Turbo Turtle Abaqus Python package directory

    Exits with a non-zero exit code if the settings variable ``_abaqus_python_parent_abspath`` does not exist.
    """
    if not _settings._abaqus_python_parent_abspath.exists():
        sys.exit("Could not find a documented path to the Abaqus Python package directory")
    else:
        print(_settings._abaqus_python_parent_abspath)




[docs]
def add_abaqus_and_cubit(parsers: typing.List[argparse.ArgumentParser]) -> None:
    """Add the Abaqus and Cubit command arguments to each parser in the parsers list

    :param list parsers: List of parsers to run ``add_argument`` for the command options
    """
    for parser in parsers:
        parser.add_argument(
            "--abaqus-command",
            nargs="+",
            default=_settings._default_abaqus_options,
            help="Abaqus executable options (default: %(default)s)",
        )
        parser.add_argument(
            "--cubit-command",
            nargs="+",
            default=_settings._default_cubit_options,
            help="Cubit executable options (default: %(default)s)",
        )
        parser.add_argument(
            "--backend",
            choices=_settings._backend_choices,
            default=_settings._default_backend,
            help="Back end software (default: %(default)s)",
        )




[docs]
def append_cubit_help(text: str, append: str = "with Abaqus, Cubit, or Gmsh (work-in-progress)") -> str:
    """Append common short help with optional Cubit text

    :param str text: original text
    :param str append: new text

    :returns: appended text
    :rtype: str
    """
    return f"{text} {append}"




[docs]
def append_cubit_description(
    text: str,
    # fmt: off
    append: str = "Defaults to Abaqus, but can optionally run Cubit (Gmsh implementation is a work-in-progress). "
                  "Cubit and Gmsh backends replace hyphens with underscores in part name(s) for ACIS "
                  "compatibility. Cubit backend ignores model/assembly name arguments.",
    # fmt: on
) -> str:
    """Append common long description with optional Cubit text

    :param str text: original text
    :param str append: new text

    :returns: appended text
    :rtype: str
    """
    return f"{text} {append}"




[docs]
def get_parser() -> argparse.ArgumentParser:
    """Get parser object for command line options

    :return: parser
    :rtype: ArgumentParser
    """
    main_description = (
        "A collection of solid body modeling tools for 2D sketched, 2D axisymmetric, and 3D revolved models. "
        "Implemented for Abaqus, Cubit, and Gmsh (work-in-progress) as backend modeling and meshing software. "
        "Most of the interface options and descriptions use Abaqus modeling concepts and language. "
        "Turbo-Turtle makes a best effort to maintain common behaviors and features across each third-party "
        "software's modeling concepts."
    )
    main_parser = argparse.ArgumentParser(
        description=main_description,
        prog=_settings._project_name_short,
    )
    main_parser.add_argument(
        "-V",
        "--version",
        action="version",
        version=f"{_settings._project_name_short} {__version__}",
    )

    subparsers = main_parser.add_subparsers(
        title="subcommands",
        metavar="{subcommand}",
        dest="subcommand",
    )

    subparsers.add_parser(
        "docs",
        help=f"Open the {_settings._project_name_short} HTML documentation",
        # fmt: off
        description=f"Open the packaged {_settings._project_name_short} HTML documentation in the "
                     "system default web browser",
        # fmt: on
        parents=[_docs.get_parser()],
    )

    subparsers.add_parser(
        "fetch",
        help=f"Fetch and copy {_settings._project_name} modsim template files and directories",
        # fmt: off
        description=f"Fetch and copy {_settings._project_name} modsim template files and directories. If no ``FILE`` "
                    "is specified, all available files will be created. Directories are recursively copied. "
                    "``pathlib.Path`` recursive pattern matching is possible. The source path is truncated to use the "
                    "shortest common file prefix, e.g. requesting two files ``common/source/file.1`` and "
                    "``common/source/file.2`` will create " "``/destination/file.1`` and ``/destination/file.2``, "
                    "respectively.",
        # fmt: on
        parents=[_fetch.get_parser()],
    )

    subparsers.add_parser(
        "print-abaqus-path",
        help="Print the absolute path to Turbo-Turtle's Abaqus Python compatible package.",
        # fmt: off
        description="***NOTE: this is an alpha feature for early adopters and developer testing of possible GUI "
                    "support*** Print the absolute path to Turbo-Turtle's Abaqus Python compatible package. "
                    "If this directory is on your PYTHONPATH, you can directly import Turbo Turtle Abaqus Python "
                    "packages in your own scrips (i.e. import turbo_turtle_abaqus.partition)",
        # fmt: on
        parents=[_print_abaqus_path_parser()],
    )

    geometry_parser = parsers.geometry_parser(add_help=False, cubit=True)
    cylinder_parser = parsers.cylinder_parser(add_help=False, cubit=True)
    sphere_parser = parsers.sphere_parser(add_help=False, cubit=True)
    partition_parser = parsers.partition_parser(add_help=False, cubit=True)
    sets_parser = parsers.sets_parser(add_help=False, cubit=True)
    mesh_parser = parsers.mesh_parser(add_help=False, cubit=True)
    image_parser = parsers.image_parser(add_help=False, cubit=True)
    merge_parser = parsers.merge_parser(add_help=False, cubit=True)
    export_parser = parsers.export_parser(add_help=False, cubit=True)

    add_abaqus_and_cubit(
        [
            geometry_parser,
            cylinder_parser,
            sphere_parser,
            partition_parser,
            sets_parser,
            mesh_parser,
            image_parser,
            merge_parser,
            export_parser,
        ]
    )

    subparsers.add_parser(
        "geometry",
        help=append_cubit_help(parsers.geometry_cli_help),
        description=append_cubit_description(parsers.geometry_cli_description),
        parents=[geometry_parser],
    )

    subparsers.add_parser(
        "geometry-xyplot",
        help="Plot the lines-and-splines as parsed by the geometry subcommand.",
        # fmt: off
        description="Plot the lines-and-splines as parsed by the geometry subcommand. "
                    "Lines are shown as solid lines with circle markers at the vertices. "
                    "Splines are show as dashed lines with plus sign markers at the vertices. "
                    "If there is more than one part, each part is shown in a unique color.",
        # fmt: on
        parents=[geometry_parser, geometry_xyplot._get_parser()],
    )

    subparsers.add_parser(
        "cylinder",
        help=append_cubit_help(parsers.cylinder_cli_help),
        description=append_cubit_description(parsers.cylinder_cli_description),
        parents=[cylinder_parser],
    )

    subparsers.add_parser(
        "sphere",
        help=append_cubit_help(parsers.sphere_cli_help),
        description=append_cubit_description(parsers.sphere_cli_description),
        parents=[sphere_parser],
    )

    subparsers.add_parser(
        "partition",
        help=append_cubit_help(parsers.partition_cli_help),
        description=append_cubit_description(parsers.partition_cli_description),
        parents=[partition_parser],
    )

    subparsers.add_parser(
        "sets",
        help=append_cubit_help(parsers.sets_cli_help),
        description=append_cubit_description(parsers.sets_cli_description),
        parents=[sets_parser],
    )

    subparsers.add_parser(
        "mesh",
        help=append_cubit_help(parsers.mesh_cli_help),
        description=append_cubit_description(parsers.mesh_cli_description),
        parents=[mesh_parser],
    )

    merge_parser = subparsers.add_parser(
        "merge",
        help=append_cubit_help(parsers.merge_cli_help),
        description=append_cubit_description(parsers.merge_cli_description),
        parents=[merge_parser],
    )

    subparsers.add_parser(
        "export",
        help=append_cubit_help(parsers.export_cli_help),
        description=append_cubit_description(parsers.export_cli_description),
        parents=[export_parser],
    )

    subparsers.add_parser(
        "image",
        help=append_cubit_help(parsers.image_cli_help),
        description=append_cubit_description(parsers.image_cli_description),
        parents=[image_parser],
    )

    return main_parser



def main() -> None:
    parser = get_parser()
    subcommand_list = parser._subparsers._group_actions[0].choices.keys()
    args = parser.parse_args()

    try:
        if args.subcommand not in subcommand_list:
            parser.print_help()
        elif args.subcommand == "docs":
            _docs.main(_settings._installed_docs_index, print_local_path=args.print_local_path)
        elif args.subcommand == "fetch":
            root_directory = _settings._tutorials_directory.parent
            relative_paths = _settings._fetch_subdirectories
            _fetch.main(
                args.subcommand,
                root_directory,
                relative_paths,
                args.destination,
                requested_paths=args.FILE,
                overwrite=args.overwrite,
                dry_run=args.dry_run,
                print_available=args.print_available,
            )
        elif args.subcommand == "print-abaqus-path":
            _print_abaqus_path_location()
        elif args.subcommand == "geometry-xyplot":
            geometry_xyplot._main(
                args.input_file,
                args.output_file,
                part_name=args.part_name,
                unit_conversion=args.unit_conversion,
                euclidean_distance=args.euclidean_distance,
                delimiter=args.delimiter,
                header_lines=args.header_lines,
                y_offset=args.y_offset,
                rtol=args.rtol,
                atol=args.atol,
                no_markers=args.no_markers,
                annotate=args.annotate,
                scale=args.scale,
            )
        else:
            _wrappers, command = _utilities.set_wrappers_and_command(args)
            wrapper_command = getattr(_wrappers, args.subcommand)
            wrapper_command(args, command)
    except RuntimeError as err:
        sys.exit(str(err))


if __name__ == "__main__":
    main()  # pragma: no cover