#!/usr/bin/python3
"""Manipulate operating state of a Starlink user terminal."""

import argparse
import logging
import sys

import grpc
from yagrc import reflector as yagrc_reflector


def parse_args():
    parser = argparse.ArgumentParser(description="Starlink user terminal state control")
    parser.add_argument("-e",
                        "--target",
                        default="192.168.100.1:9200",
                        help="host:port of dish to query, default is the standard IP address "
                        "and port (192.168.100.1:9200)")
    subs = parser.add_subparsers(dest="command", required=True)
    subs.add_parser("reboot", help="Reboot the user terminal")
    subs.add_parser("stow", help="Set user terminal to stow position")
    subs.add_parser("unstow", help="Restore user terminal from stow position")
    sleep_parser = subs.add_parser(
        "set_sleep",
        help="Show, set, or disable power save configuration",
        description="Run without arguments to show current configuration")
    sleep_parser.add_argument("start",
                              nargs="?",
                              type=int,
                              help="Start time in minutes past midnight UTC")
    sleep_parser.add_argument("duration",
                              nargs="?",
                              type=int,
                              help="Duration in minutes, or 0 to disable")

    opts = parser.parse_args()
    if opts.command == "set_sleep" and opts.start is not None:
        if opts.duration is None:
            sleep_parser.error("Must specify duration if start time is specified")
        if opts.start < 0 or opts.start >= 1440:
            sleep_parser.error("Invalid start time, must be >= 0 and < 1440")
        if opts.duration < 0 or opts.duration > 1440:
            sleep_parser.error("Invalid duration, must be >= 0 and <= 1440")
    return opts


def main():
    opts = parse_args()

    logging.basicConfig(format="%(levelname)s: %(message)s")

    reflector = yagrc_reflector.GrpcReflectionClient()
    try:
        with grpc.insecure_channel(opts.target) as channel:
            reflector.load_protocols(channel, symbols=["SpaceX.API.Device.Device"])
            stub = reflector.service_stub_class("SpaceX.API.Device.Device")(channel)
            request_class = reflector.message_class("SpaceX.API.Device.Request")
            if opts.command == "reboot":
                request = request_class(reboot={})
            elif opts.command == "stow":
                request = request_class(dish_stow={})
            elif opts.command == "unstow":
                request = request_class(dish_stow={"unstow": True})
            else:  # set_sleep
                if opts.start is None and opts.duration is None:
                    request = request_class(dish_get_config={})
                else:
                    if opts.duration:
                        request = request_class(
                            dish_power_save={
                                "power_save_start_minutes": opts.start,
                                "power_save_duration_minutes": opts.duration,
                                "enable_power_save": True
                            })
                    else:
                        # duration of 0 not allowed, even when disabled
                        request = request_class(dish_power_save={
                            "power_save_duration_minutes": 1,
                            "enable_power_save": False
                        })

            response = stub.Handle(request, timeout=10)

            if opts.command == "set_sleep" and opts.start is None and opts.duration is None:
                config = response.dish_get_config.dish_config
                if config.power_save_mode:
                    print("Sleep start:", config.power_save_start_minutes,
                          "minutes past midnight UTC")
                    print("Sleep duration:", config.power_save_duration_minutes, "minutes")
                else:
                    print("Sleep disabled")
    except (AttributeError, ValueError, grpc.RpcError) as e:
        if isinstance(e, grpc.Call):
            msg = e.details()
        elif isinstance(e, (AttributeError, ValueError)):
            msg = "Protocol error"
        else:
            msg = "Unknown communication or service error"
        logging.error(msg)
        sys.exit(1)

    sys.exit(0)


if __name__ == "__main__":
    main()