# Define Searcher class here.
# Define Searcher, hSLD, SearchNode.
import DRDViz
import math

def hSLD(node, search):
    # take the node value in
    # find the node value coordinates
    coords = search.nodeLocs[node]
    goalCoords = search.nodeLocs[search.endNode]
    # calculate the distance between the two points
    distance = math.sqrt((abs(int(coords[0]) - int(goalCoords[0])))**2 + abs(int(coords[1]) - int(goalCoords[1]))**2)
    return distance

class SearchNode:
    def __init__(self, label, pathcost):
        self.label = label
        self.pathcost = pathcost
        self.node = tuple((label, pathcost))
    def showBasic(self):
        # print(self.node) # debugging purposes
        return self.node
    def __eq__(self, object):
        return ((self.label) == (object.label))
    def __lt__(self, object):
        return ((self.label) < (object.label))
    def __repr__(self):
        return repr(self.node)

class Searcher:
    def __init__(self, mapfile, searchType, verbose=False):
        self.mapfile = mapfile
        self.searchType = searchType
        # load the mapfile's structure
        with open(self.mapfile) as mapper:
            mapContents = mapper.read()
        mapContents = mapContents.split("\n")
        for mapIter in range(len(mapContents)):
            mapContents[mapIter] = mapContents[mapIter].split(", ")
        for firstDimMapIter in range(len(mapContents) - 1):
            for secondDimMapIter in range(len(mapContents[firstDimMapIter])):
                mapContents[firstDimMapIter][secondDimMapIter] = mapContents[firstDimMapIter][secondDimMapIter].strip("')(][")
        mapContents.pop(len(mapContents) - 1)
        for tupleIter in range(len(mapContents)):
            mapContents[tupleIter] = tuple(mapContents[tupleIter])
        # print(mapContents) # list of tuples
        # print(mapContents[0]) # tuple of strings (data) 
        # [first node, second node, path cost, first node x, first node y, second node x, second node y]
        #      0            1           2            3            4              5              6
        # print(mapContents[0][0]) # data, string format
        # make two dictionaries of nodes, iterating through list of tuples to make note of every node's paths and locations
        nodeLoc = dict()
        nodePaths = dict()
        for nodeIter in range(len(mapContents)):
            # these node locations are fine, because they should technically be in only one place.
            nodeLoc[mapContents[nodeIter][0]] = tuple((mapContents[nodeIter][3], mapContents[nodeIter][4]))
            nodeLoc[mapContents[nodeIter][1]] = tuple((mapContents[nodeIter][5], mapContents[nodeIter][6]))
            # however, this is only taking the first node path it gets to...
            # I probably need a list instead, that gets updated if the node is not in the node's child list.
            # check if the key exists, if it does, then add the value to the internal dictionary,
            # if the internal dictionary doesn't exist, then create it and add the node.
            if mapContents[nodeIter][0] not in nodePaths.keys():
                nodePaths[mapContents[nodeIter][0]] = dict()
                nodePaths[mapContents[nodeIter][0]][mapContents[nodeIter][1]] = mapContents[nodeIter][2]
            else:
                if nodePaths[mapContents[nodeIter][0]].values() not in nodePaths[mapContents[nodeIter][0]].keys():
                    nodePaths[mapContents[nodeIter][0]][mapContents[nodeIter][1]] = dict()
                    nodePaths[mapContents[nodeIter][0]][mapContents[nodeIter][1]] = mapContents[nodeIter][2]
                else:
                    nodePaths[mapContents[nodeIter][0]][mapContents[nodeIter][1]] = mapContents[nodeIter][2]
            if mapContents[nodeIter][1] not in nodePaths.keys():
                nodePaths[mapContents[nodeIter][1]] = dict()
                nodePaths[mapContents[nodeIter][1]][mapContents[nodeIter][0]] = mapContents[nodeIter][2]
            else:
                if nodePaths[mapContents[nodeIter][1]].values() not in nodePaths[mapContents[nodeIter][1]].keys():
                    nodePaths[mapContents[nodeIter][1]][mapContents[nodeIter][0]] = dict()
                    nodePaths[mapContents[nodeIter][1]][mapContents[nodeIter][0]] = mapContents[nodeIter][2]
                else:
                    nodePaths[mapContents[nodeIter][1]][mapContents[nodeIter][0]] = mapContents[nodeIter][2]
        self.nodePaths = nodePaths
        self.nodeLocs = nodeLoc
        # need to get the myViz attribute by importing the DRDViz stuff.
        self.myViz = DRDViz.DRDViz()
        # now, start using the myViz thingy to 'display' a map.
        self.myViz.loadGraphFromFile(mapfile)
        self.myViz.plot()
        # create an 'open' list
        self.open = list()
    def setStartGoal(self, startNode, endNode):
        self.startNode = startNode.upper()
        self.endNode = endNode.upper()
        self.myViz.markStart(self.startNode)
        self.myViz.markGoal(self.endNode)
        # add the starting node to the 'open' list.
        starting = SearchNode(startNode, 0)
        self.open.append(starting)
    def successors(self, parentNode):
        childList = list()
        # grab the nodes from the nested dictionary given that the parentNode is a tuple.
        nodeChildren = self.nodePaths.get(parentNode.label)
        # grab each value from the dictionary, turn it into a SearchNode.
        for node in nodeChildren.keys():
            childList.append(SearchNode(node, int(nodeChildren[node])))
        # sort the child node list
        childList.sort()
        return (childList)
    def reset(self):
        # clear all the items from the open list
        self.open.clear()
        # add the start node back into the list.
        self.open.append(SearchNode(self.startNode, 0))
        # do I need to reset the visualization too?
    def insert_front(self, nodeList):
        # backwards "sort"
        # loop through each element, and apply it to the beginning of the open list.
        for item in nodeList:
            if item not in self.open:
                self.open.insert(0, item)
    def insert_end(self, nodeList):
        # forwards "sort"
        # loop through each element, and apply it to the end of the open list.
        for item in nodeList:
            if item not in self.open:
                self.open.append(item)
    def insert_ordered(self, nodeList):
        # sort by the lowest cost after adding all the elements to the open list.
        # add the nodes to the list
        self.open.extend(nodeList)
        # sort via a lambda function key, using the sorted function
        sortedList = sorted(self.open, key=lambda item: item.pathcost)
        # clear out the open list
        self.open.clear()
        # replace it with the sorted list by extending the blank list.
        self.open.extend(sortedList)
    def search(self):
        print(f"Begin Searching with type {self.searchType}")
        if self.searchType.lower() == "depth":
            print()
        elif self.searchType.lower() == "breadth":
            print()
        elif self.searchType.lower() == "best":
            print()
        elif self.searchType.lower() == "a*":
            print()
        else:
            print("Invalid searchtype.")

# 10test.txt map
x=Searcher("10test.txt", searchType="DEPTH", verbose=True)
x.setStartGoal('h','k')
x.search()

x=Searcher("10test.txt", searchType="BREADTH", verbose=True)
x.setStartGoal('h','k')
x.search()

x=Searcher("10test.txt", searchType="BEST", verbose=True)
x.setStartGoal('h','k')
x.search()

x=Searcher("10test.txt", searchType="A*", verbose=True)
x.setStartGoal('h','k')
x.search()

# 50test.txt map
x=Searcher("50test.txt", searchType="DEPTH", verbose=False)
x.setStartGoal('s','c')
x.search()

x=Searcher("50test.txt", searchType="BREADTH", verbose=False)
x.setStartGoal('s','c')
x.search()

x=Searcher("50test.txt", searchType="BEST", verbose=False)
x.setStartGoal('s','c')
x.search()

x=Searcher("50test.txt", searchType="A*", verbose=False)
x.setStartGoal('s','c')
x.search()