""""
Module to inspect phone-call events in real time.

This is the command line interface for the core.fritzmonitor module
and should serve as an example how to use an instance of FritzMonitor.

To run this, the CallMonitor service of the box has to be activated.
This can be done with any registered Phone by typing the following codes:
activate: #96*5*
deactivate: #96*4* 
"""
# This module is part of the FritzConnection package.
# https://github.com/kbr/fritzconnection
# License: MIT (https://opensource.org/licenses/MIT)
# Author: Klaus Bremer


import argparse
import queue

from ..core.fritzmonitor import (
    FritzMonitor,
    FRITZ_IP_ADDRESS,
    FRITZ_MONITOR_SOCKET_TIMEOUT,
)
from .. import __version__


HEALTHCHECK_TIMEOUT = 10


def print_header(args):
    print(f"\nfritzconnection v{__version__}")
    print(f"start fritzmonitor on address: {args.address}")
    print(f"settings for socket-timeout: {args.timeout} [sec]")
    print(f"settings for healthcheck-timeout: {args.healthcheck} [sec]")
    print("(to stop press ^C)\n")


def get_cli_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "-i",
        "--ip-address",
        nargs="?",
        default=FRITZ_IP_ADDRESS,
        const=None,
        dest="address",
        help="Specify ip-address of the FritzBox to connect to."
        "Default: %s" % FRITZ_IP_ADDRESS,
    )
    parser.add_argument(
        "-t",
        "--timeout",
        nargs="?",
        type=int,
        default=FRITZ_MONITOR_SOCKET_TIMEOUT,
        const=None,
        dest="timeout",
        help="Setting for socket timeout [sec]."
        "Default: %s" % FRITZ_MONITOR_SOCKET_TIMEOUT,
    )
    parser.add_argument(
        "-c",
        "--healthcheck",
        nargs="?",
        type=int,
        default=HEALTHCHECK_TIMEOUT,
        const=None,
        dest="healthcheck",
        help="Setting for internal health-check interval [sec]."
        "Default: %s" % HEALTHCHECK_TIMEOUT,
    )
    args = parser.parse_args()
    return args


def process_events(monitor, event_queue, healthcheck_interval):
    while True:
        try:
            event = event_queue.get(timeout=healthcheck_interval)
        except queue.Empty:
            # check health:
            if not monitor.is_alive:
                raise OSError("Error: fritzmonitor connection failed")
        else:
            # do event processing here:
            print(event)


def main():
    """
    Entry point: example to use FritzMonitor.
    """
    args = get_cli_arguments()
    print_header(args)
    # create a FritzMonitor instance and get the event_queue by calling start().
    # start() returns the queue for the events.
    try:
        with FritzMonitor(address=args.address, timeout=args.timeout) as monitor:
            event_queue = monitor.start()
            process_events(monitor, event_queue, healthcheck_interval=args.healthcheck)
    except (OSError, KeyboardInterrupt) as err:
        print(err)
    print("exit fritzmonitor")


if __name__ == "__main__":
    main()