"""Unit/functional testing for readline tab completion functions in the cmd2.py module.

These are primarily tests related to readline completer functions which handle tab completion of cmd2/cmd commands,
file system paths, and shell commands.
"""

import enum
import os
import sys
from typing import NoReturn
from unittest import mock

import pytest

import cmd2
from cmd2 import utils

from .conftest import (
    complete_tester,
    normalize,
    run_cmd,
)


class SubcommandsExample(cmd2.Cmd):
    """Example cmd2 application where we a base command which has a couple subcommands
    and the "sport" subcommand has tab completion enabled.
    """

    sport_item_strs = ('Bat', 'Basket', 'Basketball', 'Football', 'Space Ball')

    # create the top-level parser for the base command
    base_parser = cmd2.Cmd2ArgumentParser()
    base_subparsers = base_parser.add_subparsers(title='subcommands', help='subcommand help')

    # create the parser for the "foo" subcommand
    parser_foo = base_subparsers.add_parser('foo', help='foo help')
    parser_foo.add_argument('-x', type=int, default=1, help='integer')
    parser_foo.add_argument('y', type=float, help='float')
    parser_foo.add_argument('input_file', type=str, help='Input File')

    # create the parser for the "bar" subcommand
    parser_bar = base_subparsers.add_parser('bar', help='bar help')

    bar_subparsers = parser_bar.add_subparsers(title='layer3', help='help for 3rd layer of commands')
    parser_bar.add_argument('z', help='string')

    bar_subparsers.add_parser('apple', help='apple help')
    bar_subparsers.add_parser('artichoke', help='artichoke help')
    bar_subparsers.add_parser('cranberries', help='cranberries help')

    # create the parser for the "sport" subcommand
    parser_sport = base_subparsers.add_parser('sport', help='sport help')
    sport_arg = parser_sport.add_argument('sport', help='Enter name of a sport', choices=sport_item_strs)

    # create the top-level parser for the alternate command
    # The alternate command doesn't provide its own help flag
    base2_parser = cmd2.Cmd2ArgumentParser(add_help=False)
    base2_subparsers = base2_parser.add_subparsers(title='subcommands', help='subcommand help')

    # create the parser for the "foo" subcommand
    parser_foo2 = base2_subparsers.add_parser('foo', help='foo help')
    parser_foo2.add_argument('-x', type=int, default=1, help='integer')
    parser_foo2.add_argument('y', type=float, help='float')
    parser_foo2.add_argument('input_file', type=str, help='Input File')

    # create the parser for the "bar" subcommand
    parser_bar2 = base2_subparsers.add_parser('bar', help='bar help')

    bar2_subparsers = parser_bar2.add_subparsers(title='layer3', help='help for 3rd layer of commands')
    parser_bar2.add_argument('z', help='string')

    bar2_subparsers.add_parser('apple', help='apple help')
    bar2_subparsers.add_parser('artichoke', help='artichoke help')
    bar2_subparsers.add_parser('cranberries', help='cranberries help')

    # create the parser for the "sport" subcommand
    parser_sport2 = base2_subparsers.add_parser('sport', help='sport help')
    sport2_arg = parser_sport2.add_argument('sport', help='Enter name of a sport', choices=sport_item_strs)

    def __init__(self) -> None:
        super().__init__()

    # subcommand functions for the base command
    def base_foo(self, args) -> None:
        """Foo subcommand of base command."""
        self.poutput(args.x * args.y)

    def base_bar(self, args) -> None:
        """Bar subcommand of base command."""
        self.poutput(f'(({args.z}))')

    def base_sport(self, args) -> None:
        """Sport subcommand of base command."""
        self.poutput(f'Sport is {args.sport}')

    # Set handler functions for the subcommands
    parser_foo.set_defaults(func=base_foo)
    parser_bar.set_defaults(func=base_bar)
    parser_sport.set_defaults(func=base_sport)

    @cmd2.with_argparser(base_parser)
    def do_base(self, args) -> None:
        """Base command help."""
        func = getattr(args, 'func', None)
        if func is not None:
            # Call whatever subcommand function was selected
            func(self, args)
        else:
            # No subcommand was provided, so call help
            self.do_help('base')

    @cmd2.with_argparser(base2_parser)
    def do_alternate(self, args) -> None:
        """Alternate command help."""
        func = getattr(args, 'func', None)
        if func is not None:
            # Call whatever subcommand function was selected
            func(self, args)
        else:
            # No subcommand was provided, so call help
            self.do_help('alternate')


# List of strings used with completion functions
food_item_strs = ['Pizza', 'Ham', 'Ham Sandwich', 'Potato', 'Cheese "Pizza"']
sport_item_strs = ['Bat', 'Basket', 'Basketball', 'Football', 'Space Ball']
delimited_strs = [
    '/home/user/file.txt',
    '/home/user/file space.txt',
    '/home/user/prog.c',
    '/home/other user/maps',
    '/home/other user/tests',
]

# Dictionary used with flag based completion functions
flag_dict = {
    # Tab complete food items after -f and --food flag in command line
    '-f': food_item_strs,
    '--food': food_item_strs,
    # Tab complete sport items after -s and --sport flag in command line
    '-s': sport_item_strs,
    '--sport': sport_item_strs,
}

# Dictionary used with index based completion functions
index_dict = {
    1: food_item_strs,  # Tab complete food items at index 1 in command line
    2: sport_item_strs,  # Tab complete sport items at index 2 in command line
}


class CompletionsExample(cmd2.Cmd):
    """Example cmd2 application used to exercise tab completion tests"""

    def __init__(self) -> None:
        cmd2.Cmd.__init__(self, multiline_commands=['test_multiline'])
        self.foo = 'bar'
        self.add_settable(
            utils.Settable(
                'foo',
                str,
                description="a settable param",
                settable_object=self,
                completer=CompletionsExample.complete_foo_val,
            )
        )

    def do_test_basic(self, args) -> None:
        pass

    def complete_test_basic(self, text, line, begidx, endidx):
        return self.basic_complete(text, line, begidx, endidx, food_item_strs)

    def do_test_delimited(self, args) -> None:
        pass

    def complete_test_delimited(self, text, line, begidx, endidx):
        return self.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/')

    def do_test_sort_key(self, args) -> None:
        pass

    def complete_test_sort_key(self, text, line, begidx, endidx):
        num_strs = ['2', '11', '1']
        return self.basic_complete(text, line, begidx, endidx, num_strs)

    def do_test_raise_exception(self, args) -> None:
        pass

    def complete_test_raise_exception(self, text, line, begidx, endidx) -> NoReturn:
        raise IndexError("You are out of bounds!!")

    def do_test_multiline(self, args) -> None:
        pass

    def complete_test_multiline(self, text, line, begidx, endidx):
        return self.basic_complete(text, line, begidx, endidx, sport_item_strs)

    def do_test_no_completer(self, args) -> None:
        """Completing this should result in completedefault() being called"""

    def complete_foo_val(self, text, line, begidx, endidx, arg_tokens):
        """Supports unit testing cmd2.Cmd2.complete_set_val to confirm it passes all tokens in the set command"""
        if 'param' in arg_tokens:
            return ["SUCCESS"]
        return ["FAIL"]

    def completedefault(self, *ignored):
        """Method called to complete an input line when no command-specific
        complete_*() method is available.

        """
        return ['default']


@pytest.fixture
def cmd2_app():
    return CompletionsExample()


def test_complete_command_single(cmd2_app) -> None:
    text = 'he'
    line = text
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == ['help ']


def test_complete_empty_arg(cmd2_app) -> None:
    text = ''
    line = f'help {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = sorted(cmd2_app.get_visible_commands(), key=cmd2_app.default_sort_key)
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)

    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_complete_bogus_command(cmd2_app) -> None:
    text = ''
    line = f'fizbuzz {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = ['default ']
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_complete_exception(cmd2_app, capsys) -> None:
    text = ''
    line = f'test_raise_exception {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    _out, err = capsys.readouterr()

    assert first_match is None
    assert "IndexError" in err


def test_complete_macro(base_app, request) -> None:
    # Create the macro
    out, _err = run_cmd(base_app, 'macro create fake run_pyscript {1}')
    assert out == normalize("Macro 'fake' created")

    # Macros do path completion
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 's')
    line = f'fake {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    expected = [text + 'cript.py', text + 'cript.txt', text + 'cripts' + os.path.sep]
    first_match = complete_tester(text, line, begidx, endidx, base_app)
    assert first_match is not None
    assert base_app.completion_matches == expected


def test_default_sort_key(cmd2_app) -> None:
    text = ''
    line = f'test_sort_key {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    # First do alphabetical sorting
    cmd2_app.default_sort_key = cmd2.Cmd.ALPHABETICAL_SORT_KEY
    expected = ['1', '11', '2']
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected

    # Now switch to natural sorting
    cmd2_app.default_sort_key = cmd2.Cmd.NATURAL_SORT_KEY
    expected = ['1', '2', '11']
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_cmd2_command_completion_multiple(cmd2_app) -> None:
    text = 'h'
    line = text
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == ['help', 'history']


def test_cmd2_command_completion_nomatch(cmd2_app) -> None:
    text = 'fakecommand'
    line = text
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None
    assert cmd2_app.completion_matches == []


def test_cmd2_help_completion_single(cmd2_app) -> None:
    text = 'he'
    line = f'help {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert cmd2_app.completion_matches == ['help ']


def test_cmd2_help_completion_multiple(cmd2_app) -> None:
    text = 'h'
    line = f'help {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == ['help', 'history']


def test_cmd2_help_completion_nomatch(cmd2_app) -> None:
    text = 'fakecommand'
    line = f'help {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None


def test_set_allow_style_completion(cmd2_app) -> None:
    """Confirm that completing allow_style presents AllowStyle strings"""
    text = ''
    line = 'set allow_style'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = [val.name.lower() for val in cmd2.rich_utils.AllowStyle]

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match
    assert cmd2_app.completion_matches == sorted(expected, key=cmd2_app.default_sort_key)


def test_set_bool_completion(cmd2_app) -> None:
    """Confirm that completing a boolean Settable presents true and false strings"""
    text = ''
    line = 'set debug'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = ['false', 'true']

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match
    assert cmd2_app.completion_matches == sorted(expected, key=cmd2_app.default_sort_key)


def test_shell_command_completion_shortcut(cmd2_app) -> None:
    # Made sure ! runs a shell command and all matches start with ! since there
    # isn't a space between ! and the shell command. Display matches won't
    # begin with the !.
    if sys.platform == "win32":
        text = '!calc'
        expected = ['!calc.exe ']
        expected_display = ['calc.exe']
    else:
        text = '!egr'
        expected = ['!egrep ']
        expected_display = ['egrep']

    line = text
    endidx = len(line)
    begidx = 0

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected
    assert cmd2_app.display_matches == expected_display


def test_shell_command_completion_doesnt_match_wildcards(cmd2_app) -> None:
    if sys.platform == "win32":
        text = 'c*'
    else:
        text = 'e*'

    line = f'shell {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None


def test_shell_command_completion_multiple(cmd2_app) -> None:
    if sys.platform == "win32":
        text = 'c'
        expected = 'calc.exe'
    else:
        text = 'l'
        expected = 'ls'

    line = f'shell {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert expected in cmd2_app.completion_matches


def test_shell_command_completion_nomatch(cmd2_app) -> None:
    text = 'zzzz'
    line = f'shell {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None


def test_shell_command_completion_doesnt_complete_when_just_shell(cmd2_app) -> None:
    text = ''
    line = f'shell {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None


def test_shell_command_completion_does_path_completion_when_after_command(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'conftest')
    line = f'shell cat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == [text + '.py ']


def test_shell_command_complete_in_path(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 's')
    line = f'shell {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    # Since this will look for directories and executables in the given path,
    # we expect to see the scripts dir among the results
    expected = os.path.join(test_dir, 'scripts' + os.path.sep)
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert expected in cmd2_app.completion_matches


def test_path_completion_single_end(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'conftest')
    line = f'shell cat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.path_complete(text, line, begidx, endidx) == [text + '.py']


def test_path_completion_multiple(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 's')
    line = f'shell cat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    matches = cmd2_app.path_complete(text, line, begidx, endidx)
    expected = [text + 'cript.py', text + 'cript.txt', text + 'cripts' + os.path.sep]
    assert matches == expected


def test_path_completion_nomatch(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'fakepath')
    line = f'shell cat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.path_complete(text, line, begidx, endidx) == []


def test_default_to_shell_completion(cmd2_app, request) -> None:
    cmd2_app.default_to_shell = True
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'conftest')

    if sys.platform == "win32":
        command = 'calc.exe'
    else:
        command = 'egrep'

    # Make sure the command is on the testing system
    assert command in utils.get_exes_in_path(command)
    line = f'{command} {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == [text + '.py ']


def test_path_completion_no_text(cmd2_app) -> None:
    # Run path complete with no search text which should show what's in cwd
    text = ''
    line = f'shell ls {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    completions_no_text = cmd2_app.path_complete(text, line, begidx, endidx)

    # Run path complete with path set to the CWD
    text = os.getcwd() + os.path.sep
    line = f'shell ls {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    # We have to strip off the path from the beginning since the matches are entire paths
    completions_cwd = [match.replace(text, '', 1) for match in cmd2_app.path_complete(text, line, begidx, endidx)]

    # Verify that the first test gave results for entries in the cwd
    assert completions_no_text == completions_cwd
    assert completions_cwd


def test_path_completion_no_path(cmd2_app) -> None:
    # Run path complete with search text that isn't preceded by a path. This should use CWD as the path.
    text = 'p'
    line = f'shell ls {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    completions_no_text = cmd2_app.path_complete(text, line, begidx, endidx)

    # Run path complete with path set to the CWD
    text = os.getcwd() + os.path.sep + text
    line = f'shell ls {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    # We have to strip off the path from the beginning since the matches are entire paths (Leave the 's')
    completions_cwd = [match.replace(text[:-1], '', 1) for match in cmd2_app.path_complete(text, line, begidx, endidx)]

    # Verify that the first test gave results for entries in the cwd
    assert completions_no_text == completions_cwd
    assert completions_cwd


@pytest.mark.skipif(sys.platform == 'win32', reason="this only applies on systems where the root directory is a slash")
def test_path_completion_cwd_is_root_dir(cmd2_app) -> None:
    # Change our CWD to root dir
    cwd = os.getcwd()
    os.chdir(os.path.sep)

    text = ''
    line = f'shell ls {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    completions = cmd2_app.path_complete(text, line, begidx, endidx)

    # No match should start with a slash
    assert not any(match.startswith(os.path.sep) for match in completions)

    # Restore CWD
    os.chdir(cwd)


def test_path_completion_doesnt_match_wildcards(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'c*')
    line = f'shell cat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    # Currently path completion doesn't accept wildcards, so will always return empty results
    assert cmd2_app.path_complete(text, line, begidx, endidx) == []


def test_path_completion_complete_user(cmd2_app) -> None:
    import getpass

    user = getpass.getuser()

    text = f'~{user}'
    line = f'shell fake {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    completions = cmd2_app.path_complete(text, line, begidx, endidx)

    expected = text + os.path.sep
    assert expected in completions


def test_path_completion_user_path_expansion(cmd2_app) -> None:
    # Run path with a tilde and a slash
    if sys.platform.startswith('win'):
        cmd = 'dir'
    else:
        cmd = 'ls'

    # Use a ~ which will be expanded into the user's home directory
    text = f'~{os.path.sep}'
    line = f'shell {cmd} {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    completions_tilde_slash = [match.replace(text, '', 1) for match in cmd2_app.path_complete(text, line, begidx, endidx)]

    # Run path complete on the user's home directory
    text = os.path.expanduser('~') + os.path.sep
    line = f'shell {cmd} {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    completions_home = [match.replace(text, '', 1) for match in cmd2_app.path_complete(text, line, begidx, endidx)]

    assert completions_tilde_slash == completions_home


def test_path_completion_directories_only(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 's')
    line = f'shell cat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    expected = [text + 'cripts' + os.path.sep]

    assert cmd2_app.path_complete(text, line, begidx, endidx, path_filter=os.path.isdir) == expected


def test_basic_completion_single(cmd2_app) -> None:
    text = 'Pi'
    line = f'list_food -f {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.basic_complete(text, line, begidx, endidx, food_item_strs) == ['Pizza']


def test_basic_completion_multiple(cmd2_app) -> None:
    text = ''
    line = f'list_food -f {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    matches = sorted(cmd2_app.basic_complete(text, line, begidx, endidx, food_item_strs))
    assert matches == sorted(food_item_strs)


def test_basic_completion_nomatch(cmd2_app) -> None:
    text = 'q'
    line = f'list_food -f {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.basic_complete(text, line, begidx, endidx, food_item_strs) == []


def test_delimiter_completion_partial(cmd2_app) -> None:
    """Test that a delimiter is added when an item has not been fully completed"""
    text = '/home/'
    line = f'command {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    matches = cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/')

    # All matches end with the delimiter
    matches.sort(key=cmd2_app.default_sort_key)
    expected_matches = sorted(["/home/other user/", "/home/user/"], key=cmd2_app.default_sort_key)

    cmd2_app.display_matches.sort(key=cmd2_app.default_sort_key)
    expected_display = sorted(["other user/", "user/"], key=cmd2_app.default_sort_key)

    assert matches == expected_matches
    assert cmd2_app.display_matches == expected_display


def test_delimiter_completion_full(cmd2_app) -> None:
    """Test that no delimiter is added when an item has been fully completed"""
    text = '/home/other user/'
    line = f'command {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    matches = cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/')

    # No matches end with the delimiter
    matches.sort(key=cmd2_app.default_sort_key)
    expected_matches = sorted(["/home/other user/maps", "/home/other user/tests"], key=cmd2_app.default_sort_key)

    cmd2_app.display_matches.sort(key=cmd2_app.default_sort_key)
    expected_display = sorted(["maps", "tests"], key=cmd2_app.default_sort_key)

    assert matches == expected_matches
    assert cmd2_app.display_matches == expected_display


def test_delimiter_completion_nomatch(cmd2_app) -> None:
    text = '/nothing_to_see'
    line = f'command {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.delimiter_complete(text, line, begidx, endidx, delimited_strs, '/') == []


def test_flag_based_completion_single(cmd2_app) -> None:
    text = 'Pi'
    line = f'list_food -f {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.flag_based_complete(text, line, begidx, endidx, flag_dict) == ['Pizza']


def test_flag_based_completion_multiple(cmd2_app) -> None:
    text = ''
    line = f'list_food -f {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    matches = sorted(cmd2_app.flag_based_complete(text, line, begidx, endidx, flag_dict))
    assert matches == sorted(food_item_strs)


def test_flag_based_completion_nomatch(cmd2_app) -> None:
    text = 'q'
    line = f'list_food -f {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.flag_based_complete(text, line, begidx, endidx, flag_dict) == []


def test_flag_based_default_completer(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'c')
    line = f'list_food {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.flag_based_complete(text, line, begidx, endidx, flag_dict, all_else=cmd2_app.path_complete) == [
        text + 'onftest.py'
    ]


def test_flag_based_callable_completer(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'c')
    line = f'list_food -o {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    flag_dict['-o'] = cmd2_app.path_complete
    assert cmd2_app.flag_based_complete(text, line, begidx, endidx, flag_dict) == [text + 'onftest.py']


def test_index_based_completion_single(cmd2_app) -> None:
    text = 'Foo'
    line = f'command Pizza {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.index_based_complete(text, line, begidx, endidx, index_dict) == ['Football']


def test_index_based_completion_multiple(cmd2_app) -> None:
    text = ''
    line = f'command Pizza {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    matches = sorted(cmd2_app.index_based_complete(text, line, begidx, endidx, index_dict))
    assert matches == sorted(sport_item_strs)


def test_index_based_completion_nomatch(cmd2_app) -> None:
    text = 'q'
    line = f'command {text}'
    endidx = len(line)
    begidx = endidx - len(text)
    assert cmd2_app.index_based_complete(text, line, begidx, endidx, index_dict) == []


def test_index_based_default_completer(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'c')
    line = f'command Pizza Bat Computer {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    assert cmd2_app.index_based_complete(text, line, begidx, endidx, index_dict, all_else=cmd2_app.path_complete) == [
        text + 'onftest.py'
    ]


def test_index_based_callable_completer(cmd2_app, request) -> None:
    test_dir = os.path.dirname(request.module.__file__)

    text = os.path.join(test_dir, 'c')
    line = f'command Pizza Bat {text}'

    endidx = len(line)
    begidx = endidx - len(text)

    index_dict[3] = cmd2_app.path_complete
    assert cmd2_app.index_based_complete(text, line, begidx, endidx, index_dict) == [text + 'onftest.py']


def test_tokens_for_completion_quoted(cmd2_app) -> None:
    text = 'Pi'
    line = f'list_food "{text}"'
    endidx = len(line)
    begidx = endidx

    expected_tokens = ['list_food', 'Pi', '']
    expected_raw_tokens = ['list_food', '"Pi"', '']

    tokens, raw_tokens = cmd2_app.tokens_for_completion(line, begidx, endidx)
    assert expected_tokens == tokens
    assert expected_raw_tokens == raw_tokens


def test_tokens_for_completion_unclosed_quote(cmd2_app) -> None:
    text = 'Pi'
    line = f'list_food "{text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_tokens = ['list_food', 'Pi']
    expected_raw_tokens = ['list_food', '"Pi']

    tokens, raw_tokens = cmd2_app.tokens_for_completion(line, begidx, endidx)
    assert expected_tokens == tokens
    assert expected_raw_tokens == raw_tokens


def test_tokens_for_completion_punctuation(cmd2_app) -> None:
    """Test that redirectors and terminators are word delimiters"""
    text = 'file'
    line = f'command | < ;>>{text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_tokens = ['command', '|', '<', ';', '>>', 'file']
    expected_raw_tokens = ['command', '|', '<', ';', '>>', 'file']

    tokens, raw_tokens = cmd2_app.tokens_for_completion(line, begidx, endidx)
    assert expected_tokens == tokens
    assert expected_raw_tokens == raw_tokens


def test_tokens_for_completion_quoted_punctuation(cmd2_app) -> None:
    """Test that quoted punctuation characters are not word delimiters"""
    text = '>file'
    line = f'command "{text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_tokens = ['command', '>file']
    expected_raw_tokens = ['command', '">file']

    tokens, raw_tokens = cmd2_app.tokens_for_completion(line, begidx, endidx)
    assert expected_tokens == tokens
    assert expected_raw_tokens == raw_tokens


def test_add_opening_quote_basic_no_text(cmd2_app) -> None:
    text = ''
    line = f'test_basic {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    # The whole list will be returned with no opening quotes added
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == sorted(food_item_strs, key=cmd2_app.default_sort_key)


def test_add_opening_quote_basic_nothing_added(cmd2_app) -> None:
    text = 'P'
    line = f'test_basic {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == ['Pizza', 'Potato']


def test_add_opening_quote_basic_quote_added(cmd2_app) -> None:
    text = 'Ha'
    line = f'test_basic {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = sorted(['"Ham', '"Ham Sandwich'], key=cmd2_app.default_sort_key)
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_add_opening_quote_basic_single_quote_added(cmd2_app) -> None:
    text = 'Ch'
    line = f'test_basic {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = ["'Cheese \"Pizza\"' "]
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_add_opening_quote_basic_text_is_common_prefix(cmd2_app) -> None:
    # This tests when the text entered is the same as the common prefix of the matches
    text = 'Ham'
    line = f'test_basic {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = sorted(['"Ham', '"Ham Sandwich'], key=cmd2_app.default_sort_key)
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_add_opening_quote_delimited_no_text(cmd2_app) -> None:
    text = ''
    line = f'test_delimited {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    # Matches returned with no opening quote
    expected_matches = sorted(["/home/other user/", "/home/user/"], key=cmd2_app.default_sort_key)
    expected_display = sorted(["other user/", "user/"], key=cmd2_app.default_sort_key)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected_matches
    assert cmd2_app.display_matches == expected_display


def test_add_opening_quote_delimited_nothing_added(cmd2_app) -> None:
    text = '/home/'
    line = f'test_delimited {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_matches = sorted(['/home/other user/', '/home/user/'], key=cmd2_app.default_sort_key)
    expected_display = sorted(['other user/', 'user/'], key=cmd2_app.default_sort_key)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected_matches
    assert cmd2_app.display_matches == expected_display


def test_add_opening_quote_delimited_quote_added(cmd2_app) -> None:
    text = '/home/user/fi'
    line = f'test_delimited {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_common_prefix = '"/home/user/file'
    expected_display = sorted(['file.txt', 'file space.txt'], key=cmd2_app.default_sort_key)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert os.path.commonprefix(cmd2_app.completion_matches) == expected_common_prefix
    assert cmd2_app.display_matches == expected_display


def test_add_opening_quote_delimited_text_is_common_prefix(cmd2_app) -> None:
    # This tests when the text entered is the same as the common prefix of the matches
    text = '/home/user/file'
    line = f'test_delimited {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_common_prefix = '"/home/user/file'
    expected_display = sorted(['file.txt', 'file space.txt'], key=cmd2_app.default_sort_key)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert os.path.commonprefix(cmd2_app.completion_matches) == expected_common_prefix
    assert cmd2_app.display_matches == expected_display


def test_add_opening_quote_delimited_space_in_prefix(cmd2_app) -> None:
    # This tests when a space appears before the part of the string that is the display match
    text = '/home/oth'
    line = f'test_delimited {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected_common_prefix = '"/home/other user/'
    expected_display = ['maps', 'tests']

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert os.path.commonprefix(cmd2_app.completion_matches) == expected_common_prefix
    assert cmd2_app.display_matches == expected_display


def test_no_completer(cmd2_app) -> None:
    text = ''
    line = f'test_no_completer {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = ['default ']
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_wordbreak_in_command(cmd2_app) -> None:
    text = ''
    line = f'"{text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None
    assert not cmd2_app.completion_matches


def test_complete_multiline_on_single_line(cmd2_app) -> None:
    text = ''
    line = f'test_multiline {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = sorted(sport_item_strs, key=cmd2_app.default_sort_key)
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)

    assert first_match is not None
    assert cmd2_app.completion_matches == expected


def test_complete_multiline_on_multiple_lines(cmd2_app) -> None:
    # Set the same variables _complete_statement() sets when a user is entering data at a continuation prompt
    cmd2_app._at_continuation_prompt = True
    cmd2_app._multiline_in_progress = "test_multiline\n"

    text = 'Ba'
    line = f'{text}'
    endidx = len(line)
    begidx = endidx - len(text)

    expected = sorted(['Bat', 'Basket', 'Basketball'], key=cmd2_app.default_sort_key)
    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)

    assert first_match is not None
    assert cmd2_app.completion_matches == expected


# Used by redirect_complete tests
class RedirCompType(enum.Enum):
    SHELL_CMD = (1,)
    PATH = (2,)
    DEFAULT = (3,)
    NONE = 4


@pytest.mark.parametrize(
    ('line', 'comp_type'),
    [
        ('fake', RedirCompType.DEFAULT),
        ('fake arg', RedirCompType.DEFAULT),
        ('fake |', RedirCompType.SHELL_CMD),
        ('fake | grep', RedirCompType.PATH),
        ('fake | grep arg', RedirCompType.PATH),
        ('fake | grep >', RedirCompType.PATH),
        ('fake | grep > >', RedirCompType.NONE),
        ('fake | grep > file', RedirCompType.NONE),
        ('fake | grep > file >', RedirCompType.NONE),
        ('fake | grep > file |', RedirCompType.SHELL_CMD),
        ('fake | grep > file | grep', RedirCompType.PATH),
        ('fake | |', RedirCompType.NONE),
        ('fake | >', RedirCompType.NONE),
        ('fake >', RedirCompType.PATH),
        ('fake >>', RedirCompType.PATH),
        ('fake > >', RedirCompType.NONE),
        ('fake > |', RedirCompType.SHELL_CMD),
        ('fake >> file |', RedirCompType.SHELL_CMD),
        ('fake >> file | grep', RedirCompType.PATH),
        ('fake > file', RedirCompType.NONE),
        ('fake > file >', RedirCompType.NONE),
        ('fake > file >>', RedirCompType.NONE),
    ],
)
def test_redirect_complete(cmd2_app, monkeypatch, line, comp_type) -> None:
    # Test both cases of allow_redirection
    cmd2_app.allow_redirection = True
    for _ in range(2):
        shell_cmd_complete_mock = mock.MagicMock(name='shell_cmd_complete')
        monkeypatch.setattr("cmd2.Cmd.shell_cmd_complete", shell_cmd_complete_mock)

        path_complete_mock = mock.MagicMock(name='path_complete')
        monkeypatch.setattr("cmd2.Cmd.path_complete", path_complete_mock)

        default_complete_mock = mock.MagicMock(name='fake_completer')

        text = ''
        line = f'{line} {text}'
        endidx = len(line)
        begidx = endidx - len(text)

        cmd2_app._redirect_complete(text, line, begidx, endidx, default_complete_mock)

        if comp_type == RedirCompType.SHELL_CMD:
            shell_cmd_complete_mock.assert_called_once()
        elif comp_type == RedirCompType.PATH:
            path_complete_mock.assert_called_once()
        elif comp_type == RedirCompType.DEFAULT:
            default_complete_mock.assert_called_once()
        else:
            shell_cmd_complete_mock.assert_not_called()
            path_complete_mock.assert_not_called()
            default_complete_mock.assert_not_called()

        # Do the next test with allow_redirection as False
        cmd2_app.allow_redirection = False
        if comp_type != RedirCompType.DEFAULT:
            comp_type = RedirCompType.NONE


def test_complete_set_value(cmd2_app) -> None:
    text = ''
    line = f'set foo {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match == "SUCCESS "
    assert cmd2_app.completion_hint == "Hint:\n  value  a settable param\n"


def test_complete_set_value_invalid_settable(cmd2_app, capsys) -> None:
    text = ''
    line = f'set fake {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, cmd2_app)
    assert first_match is None

    out, _err = capsys.readouterr()
    assert "fake is not a settable parameter" in out


@pytest.fixture
def sc_app():
    c = SubcommandsExample()
    c.stdout = utils.StdSim(c.stdout)
    return c


def test_cmd2_subcommand_completion_single_end(sc_app) -> None:
    text = 'f'
    line = f'base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert sc_app.completion_matches == ['foo ']


def test_cmd2_subcommand_completion_multiple(sc_app) -> None:
    text = ''
    line = f'base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)
    assert first_match is not None
    assert sc_app.completion_matches == ['bar', 'foo', 'sport']


def test_cmd2_subcommand_completion_nomatch(sc_app) -> None:
    text = 'z'
    line = f'base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)
    assert first_match is None


def test_help_subcommand_completion_single(sc_app) -> None:
    text = 'base'
    line = f'help {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert sc_app.completion_matches == ['base ']


def test_help_subcommand_completion_multiple(sc_app) -> None:
    text = ''
    line = f'help base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)
    assert first_match is not None
    assert sc_app.completion_matches == ['bar', 'foo', 'sport']


def test_help_subcommand_completion_nomatch(sc_app) -> None:
    text = 'z'
    line = f'help base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)
    assert first_match is None


def test_subcommand_tab_completion(sc_app) -> None:
    # This makes sure the correct completer for the sport subcommand is called
    text = 'Foot'
    line = f'base sport {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert sc_app.completion_matches == ['Football ']


def test_subcommand_tab_completion_with_no_completer(sc_app) -> None:
    # This tests what happens when a subcommand has no completer
    # In this case, the foo subcommand has no completer defined
    text = 'Foot'
    line = f'base foo {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)
    assert first_match is None


def test_subcommand_tab_completion_space_in_text(sc_app) -> None:
    text = 'B'
    line = f'base sport "Space {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, sc_app)

    assert first_match is not None
    assert sc_app.completion_matches == ['Ball" ']
    assert sc_app.display_matches == ['Space Ball']


####################################################


class SubcommandsWithUnknownExample(cmd2.Cmd):
    """Example cmd2 application where we a base command which has a couple subcommands
    and the "sport" subcommand has tab completion enabled.
    """

    def __init__(self) -> None:
        cmd2.Cmd.__init__(self)

    # subcommand functions for the base command
    def base_foo(self, args) -> None:
        """Foo subcommand of base command"""
        self.poutput(args.x * args.y)

    def base_bar(self, args) -> None:
        """Bar subcommand of base command"""
        self.poutput(f'(({args.z}))')

    def base_sport(self, args) -> None:
        """Sport subcommand of base command"""
        self.poutput(f'Sport is {args.sport}')

    # create the top-level parser for the base command
    base_parser = cmd2.Cmd2ArgumentParser()
    base_subparsers = base_parser.add_subparsers(title='subcommands', help='subcommand help')

    # create the parser for the "foo" subcommand
    parser_foo = base_subparsers.add_parser('foo', help='foo help')
    parser_foo.add_argument('-x', type=int, default=1, help='integer')
    parser_foo.add_argument('y', type=float, help='float')
    parser_foo.set_defaults(func=base_foo)

    # create the parser for the "bar" subcommand
    parser_bar = base_subparsers.add_parser('bar', help='bar help')
    parser_bar.add_argument('z', help='string')
    parser_bar.set_defaults(func=base_bar)

    # create the parser for the "sport" subcommand
    parser_sport = base_subparsers.add_parser('sport', help='sport help')
    sport_arg = parser_sport.add_argument('sport', help='Enter name of a sport', choices=sport_item_strs)

    @cmd2.with_argparser(base_parser, with_unknown_args=True)
    def do_base(self, args) -> None:
        """Base command help"""
        func = getattr(args, 'func', None)
        if func is not None:
            # Call whatever subcommand function was selected
            func(self, args)
        else:
            # No subcommand was provided, so call help
            self.do_help('base')


@pytest.fixture
def scu_app():
    """Declare test fixture for with_argparser decorator"""
    return SubcommandsWithUnknownExample()


def test_subcmd_with_unknown_completion_single_end(scu_app) -> None:
    text = 'f'
    line = f'base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)

    print(f'first_match: {first_match}')

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert scu_app.completion_matches == ['foo ']


def test_subcmd_with_unknown_completion_multiple(scu_app) -> None:
    text = ''
    line = f'base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is not None
    assert scu_app.completion_matches == ['bar', 'foo', 'sport']


def test_subcmd_with_unknown_completion_nomatch(scu_app) -> None:
    text = 'z'
    line = f'base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is None


def test_help_subcommand_completion_single_scu(scu_app) -> None:
    text = 'base'
    line = f'help {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert scu_app.completion_matches == ['base ']


def test_help_subcommand_completion_multiple_scu(scu_app) -> None:
    text = ''
    line = f'help base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is not None
    assert scu_app.completion_matches == ['bar', 'foo', 'sport']


def test_help_subcommand_completion_with_flags_before_command(scu_app) -> None:
    text = ''
    line = f'help -h -v base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is not None
    assert scu_app.completion_matches == ['bar', 'foo', 'sport']


def test_complete_help_subcommands_with_blank_command(scu_app) -> None:
    text = ''
    line = f'help "" {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is None
    assert not scu_app.completion_matches


def test_help_subcommand_completion_nomatch_scu(scu_app) -> None:
    text = 'z'
    line = f'help base {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is None


def test_subcommand_tab_completion_scu(scu_app) -> None:
    # This makes sure the correct completer for the sport subcommand is called
    text = 'Foot'
    line = f'base sport {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)

    # It is at end of line, so extra space is present
    assert first_match is not None
    assert scu_app.completion_matches == ['Football ']


def test_subcommand_tab_completion_with_no_completer_scu(scu_app) -> None:
    # This tests what happens when a subcommand has no completer
    # In this case, the foo subcommand has no completer defined
    text = 'Foot'
    line = f'base foo {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)
    assert first_match is None


def test_subcommand_tab_completion_space_in_text_scu(scu_app) -> None:
    text = 'B'
    line = f'base sport "Space {text}'
    endidx = len(line)
    begidx = endidx - len(text)

    first_match = complete_tester(text, line, begidx, endidx, scu_app)

    assert first_match is not None
    assert scu_app.completion_matches == ['Ball" ']
    assert scu_app.display_matches == ['Space Ball']
