#!/usr/bin/env python
"""An example cmd2 mixin."""

import functools
from collections.abc import Callable
from typing import TYPE_CHECKING

import cmd2

if TYPE_CHECKING:  # pragma: no cover
    _Base = cmd2.Cmd
else:
    _Base = object


def empty_decorator(func: Callable) -> Callable:
    """An empty decorator for use with your mixin."""

    @functools.wraps(func)
    def _empty_decorator(self, *args, **kwargs) -> None:
        self.poutput("in the empty decorator")
        func(self, *args, **kwargs)

    _empty_decorator.__doc__ = func.__doc__
    return _empty_decorator


class MyMixin(_Base):
    """A mixin class which adds a 'say' command to a cmd2 subclass.

    The order in which you add the mixin matters. Say you want to
    use this mixin in a class called MyApp.

    class MyApp(MyMixin, cmd2.Cmd):
        def __init__(self, *args, **kwargs):
            # gotta have this or neither the mixin or cmd2 will initialize
            super().__init__(*args, **kwargs)
    """

    def __init__(self, *args, **kwargs) -> None:
        # code placed here runs before cmd2 initializes
        super().__init__(*args, **kwargs)
        # code placed here runs after cmd2 initializes
        # this is where you register any hook functions
        self.register_preloop_hook(self.cmd2_mymixin_preloop_hook)
        self.register_postloop_hook(self.cmd2_mymixin_postloop_hook)
        self.register_postparsing_hook(self.cmd2_mymixin_postparsing_hook)

    def do_say(self, statement) -> None:
        """Simple say command."""
        self.poutput(statement)

    #
    # define hooks as functions, not methods
    def cmd2_mymixin_preloop_hook(self) -> None:
        """Method to be called before the command loop begins."""
        self.poutput("preloop hook")

    def cmd2_mymixin_postloop_hook(self) -> None:
        """Method to be called after the command loop finishes."""
        self.poutput("postloop hook")

    def cmd2_mymixin_postparsing_hook(self, data: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:
        """Method to be called after parsing user input, but before running the command."""
        self.poutput('in postparsing hook')
        return data


class Example(MyMixin, cmd2.Cmd):
    """An class to show how to use a mixin."""

    def __init__(self, *args, **kwargs) -> None:
        # gotta have this or neither the mixin or cmd2 will initialize
        super().__init__(*args, **kwargs)

    @empty_decorator
    def do_something(self, _arg) -> None:
        self.poutput('this is the something command')


if __name__ == '__main__':
    app = Example()
    app.cmdloop()