from modules.user import info as user_info
from modules.algorithms.univ import dict_key_verify
from modules.algorithms.uuid import hash_string

class User():
    def __init__(self, username, origin=False):
        self.username = username
        self.friends = user_info.friend(username=username)
        self.origin = origin

        self.exclude = []
        self.count = 1
        self.depth = 0
        self.score = 0

        self.friend_list = []

    def find_friends(self, exclude=[], **kwargs):
        self.exclude += exclude
        friends = self.friends.get()
        if dict_key_verify(friends, "friends"):
            self.__organise_friends(friends['friends'])

        self.__find_excluded()

    def __organise_friends(self, friends, **kwargs):
        for friend in friends:
            if friend['username'] not in self.exclude:
                self.friend_list.append(User(friend['username']))

    def __find_excluded(self):
        if self.username not in self.exclude:
            self.exclude.append(self.username)
        if self.origin:
            self.exclude = self.exclude + [friend.username for friend in self.friend_list]
            requests = self.friends.get_requests()
            print(f"requests: {requests}")
            if dict_key_verify(requests, "requests"):
                self.exclude = self.exclude + [request for request in requests["requests"]]
                print(f"EXCLUDED: {self.exclude}")

    def __hash__(self):
        obj_hash = hash_string(self.username)
        return obj_hash

class Graph():
    def __init__(self, username):
        self.origin_user = User(username, True)
        self.graph = [[]] * (10**7+7)

        self.friend_directory = [None] * (10**7+7)
        self.friend_directory[hash(self.origin_user)] = self.origin_user
        self.exclude = []

    def generate(self, depth=1):
        self.__add_user_friends(self.origin_user, self.origin_user, depth)

    def __add_user_friends(self, origin, source, depth):
        origin.find_friends(self.exclude + [source.username])
        if hash(self.origin_user) == hash(origin):
            self.exclude += origin.exclude

        for friend in origin.friend_list:
            friend_hash = hash(friend)
            self.__add_edge(hash(origin), friend_hash)
            if self.friend_directory[friend_hash]:
                self.friend_directory[friend_hash].count += 1
                self.friend_directory[friend_hash].depth += depth
            else:
                self.friend_directory[friend_hash] = friend

            if depth-1 > 0:
                self.__add_user_friends(friend, origin, depth-1)

    def __add_edge(self, node, edge):
        self.graph[node] = self.graph[node] + [edge]


    def dft(self):
        self.visted = []
        self.edge_stack = [hash(self.origin_user)]
        self.edge_queue = [hash(self.origin_user)]

        self.__visit(self.edge_stack[0])

    def __visit(self, origin):
        start_pos = self.graph[origin]
        self.__on_visit(origin)

        self.edge_stack.pop(len(self.edge_stack)-1)
        self.visted.append(origin)

        for neigbour in start_pos:
            if neigbour not in self.visted and neigbour not in self.edge_stack:
                self.edge_stack.append(neigbour)

        while len(self.edge_stack) > 0:
            i = len(self.edge_stack) - 1
            self.__visit(self.edge_stack[i])

    def __on_visit(self, origin):
        origin_obj = self.friend_directory[origin]
        origin_obj.score += origin_obj.depth

    def recomend_friends(self):
        self.recomendations = []
        while len(self.recomendations) != len(self.visted):
            largest = User(username="")
            largest.score = -1
            for friend in self.visted:
                friend_obj = self.friend_directory[friend]
                if friend_obj not in self.recomendations and friend_obj.score > largest.score:
                    largest = friend_obj
            self.recomendations.append(largest)

def recomend_friend(amount=1, depth=1):
    if depth not in [1, 2, 3, 4]:
        depth = 4
    friend_graph = Graph("user1")
    friend_graph.generate(depth)
    friend_graph.dft()
    friend_graph.recomend_friends()

    recomended = [{'username': recomended.username} for recomended in friend_graph.recomendations[:amount]]
    print(recomended)
    return recomended

def main():
    recomend_friend(3, 4)

if __name__ == "__main__":
    main()