from graph import *
from utils import getNode


def traverse(graph, frontier, start_node_name, target_node_name):
    explored = []
    path = []

    # node
    start_node = getNode(start_node_name, graph.nodes)
    start_node.value = 0

    target_node = getNode(target_node_name, graph.nodes)

    frontier.push(start_node)

    while not frontier.empty():
        current_node = frontier.pop()

        if not current_node == target_node:
            explored.append(current_node.name)

            for edge in current_node.edges:
                child = edge.end
                new_cost = current_node.value + edge.value

                if not explored.__contains__(child.name):
                    child.parent = current_node
                    child.value = new_cost
                    frontier.push(child)

                # UCS-only, updating the value and parent of node in the queue
                elif frontier.type == 'PRIO' and new_cost < child.value:
                    for node in frontier.items:
                        if node.name == child.name:
                            node.value = new_cost
                            node.parent = current_node
                            frontier.items.sort(key=lambda item: item.value)
                            break

        else:
            path.append(current_node.name)
            while not current_node == start_node:
                current_node = current_node.parent
                path.insert(0, current_node.name)
            break

    if len(path) == 0:
        print('zwischen ' + start_node_name + ' und ' + target_node_name + ' konnte kein Pfad gefunden werden')
    else:
        print('From ' + start_node_name + ' to ' + target_node_name + ': ')
        print('Path: ' + path.__str__().format())
        print('Cost: ' + target_node.value.__str__())


def bfs(graph, start_node_name, target_node_name):
    traverse(graph, Queue('FIFO'), start_node_name, target_node_name)


def dfs(graph, start_node_name, target_node_name):
    traverse(graph, Queue('LIFO'), start_node_name, target_node_name)


def ucs(graph, start_node_name, target_node_name):
    traverse(graph, Queue('PRIO'), start_node_name, target_node_name)