import argparse
import configparser
import math
import os
import sys
import ywalk.parser as Parser

from ywalk.types import Mode, Place
from ywalk.graph import Graph

class ParseModeRestriction(argparse.Action):
    def __call__(self, parser, namespace, args, option_string=None):
        arglist = set(args.split(','))

        for arg in arglist:
            if arg.upper() not in Mode.__members__:
                errx(f'Not a valid Mode: {arg}')

        modes = [Mode[arg.upper()] for arg in arglist]

        saved = getattr(namespace, self.dest) or []
        saved.extend(modes)
        setattr(namespace, self.dest, saved)

# pylint: disable=line-too-long
cli = argparse.ArgumentParser()
cli.add_argument('place', type=Place, nargs='*', help='a place in Morrowind')
cli.add_argument('-w', dest='weight_spec', metavar='WEIGHTING_METHOD', help='the weighting method to apply when searching for a route')
cli.add_argument('-P', dest='deny_places', type=Place, action='append', metavar='PLACE', help='avoid traveling through this place')
cli.add_argument('-m', dest='allow_modes', action=ParseModeRestriction, metavar='MODES', help='allow only these modes of travel')
cli.add_argument('-M', dest='deny_modes', action=ParseModeRestriction, metavar='MODES', help='deny these modes of travel')
cli.add_argument('-T', dest='deny_teleport', action='store_true', help='deny teleportation')

def errx(msg):
    sys.exit(f'ywalk: {msg}')

def pretty_print_path(path):
    origin = path[0].origin
    destination = path[-1].destination

    time = 0
    print(f'Start in {origin}')
    for conn in path:
        time = time + conn.time

        print(f' then {conn.mode.pretty} to {conn.destination}', end='')
        if conn.time:
            print(f' ({conn.time} {"hour" if conn.time == 1 else "hours"})')
        else:
            print()

    if time:
        print(f'Arrive in {destination} after {time} hours.')

def pretty_print_place(place, graph):
    def pretty_print_connections(conns):
        for conn in sorted(conns, key=lambda c: c.mode.value):
            print(conn)

    print(f'Direct connections from {place}:')
    pretty_print_connections(graph.get_connections_from(place))
    print()

    print(f'Direct connections to {place}:')
    pretty_print_connections(graph.get_connections_to(place))

    print()
    print ('Reachability map:')
    weights, _ = graph.shortest_paths(place)
    for destination in sorted(weights.keys(), key=weights.get):
        if place == destination:
            continue

        reachability = "unreachable" if weights[destination] == math.inf else weights[destination]
        print(f'{destination}: {reachability}')

def get_xdg_home(xdg_type, fallback):
    env = f'XDG_{xdg_type}_HOME'
    if env in os.environ:
        return os.environ[env]
    return os.path.expanduser(fallback)

def apply_predicates(args, graph):
    if args.allow_modes:
        graph.add_predicate(lambda c: c.mode in args.allow_modes)

    if args.deny_modes:
        graph.add_predicate(lambda c: c.mode not in args.deny_modes)

    if args.deny_teleport:
        graph.add_predicate(lambda c: not c.mode.teleport)

    if args.deny_places:
        graph.add_predicate(lambda c: c.destination not in args.deny_places)

def main():
    args = cli.parse_intermixed_args()

    config = configparser.ConfigParser()
    config.read(os.path.join(get_xdg_home('CONFIG', '~/.config'), 'ywalk', 'config'))

    datafile = config.get('misc', 'data', fallback='goty')
    datapath = os.path.join(get_xdg_home('DATA', '~/.local/share'), 'ywalk', f'{datafile}.tsv')

    graph = Graph()

    try:
        graph.populate(Parser.parse_tsv(datapath))
    except (FileNotFoundError, Parser.InputError, ValueError) as err:
        errx(err)

    recall = config.get('misc', 'recall', fallback=None)
    if recall:
        graph.add_recall(Place(recall))

    for place in args.place:
        if place not in graph:
            errx(f'Can\'t find "{place}".')

    graph.set_weight(args.weight_spec or config.get('misc', 'weighting_method', fallback=None))
    apply_predicates(args, graph)

    if not args.place:
        for place in sorted(graph.get_places(), key=lambda p: p.name):
            print(place)
    elif len(args.place) == 1:
        pretty_print_place(args.place[0], graph)
    elif len(args.place) > 1:
        path = graph.find_path(*args.place)
        if path is None:
            errx(f'Graph exhausted, no connection between {", ".join(map(str, args.place))}')

        pretty_print_path(path)

if __name__ == '__main__':
    main()