import math
import random
from model.base_model import Model

class MyUCSModel(Model):
    def __init__(self):
        super().__init__()

    def init(self, nodes):
        """
        Put your initialization here.
        """
        super().init(nodes)

    def getMST(self, node):
        MST = []
        distances = []
        for i in range(0, self.N):
            if i != node:
                MST.append(i)
                distances.append(self.dist(node, i))
        return [x for _,x in sorted(zip(distances, MST))]

    def fit(self, max_it=1000):
        """
        Put your iteration process here.
        """

        UCS_solutions = []
        UCS_losses = []
    
        for i in range(0, self.N):
            solution = [i]
            UCS_solutions.append(solution)
            UCS_losses.append(math.inf)
    
        MSTs = []
        for i in range(0, self.N):
            MSTs.append([-1] * self.N)

        # Breadth First: Set each city as starting point, then go to next city simultaneously
        min_loss = math.inf
        while(len(UCS_solutions[ UCS_losses.index(min(UCS_losses)) ]) != self.N):
            unvisited_list = list(range(0, self.N))
            min_loss = min(UCS_losses)
            # For each search path
            for i in range(0, self.N):
                if UCS_losses[i] == min_loss:
                    cur_city = UCS_solutions[i][-1]
                    unvisited_list = list( set(range(0, self.N)) - set(UCS_solutions[i]) )
                    if MSTs[cur_city][0] == -1:
                        MST = self.getMST(cur_city)
                        MSTs[cur_city] = MST

                    for j in MSTs[cur_city]:
                        if(j in unvisited_list):
                            UCS_solutions[i].append(j)

                            N = len(UCS_solutions[i])
                            cur_fit = 0
                            for k in range(len(UCS_solutions[i])):
                                coord_0, coord_1 = self.coords[UCS_solutions[i][k % N]], self.coords[UCS_solutions[i][(k + 1) % N]]
                                cur_fit += math.sqrt((coord_0[0] - coord_1[0]) ** 2 + (coord_0[1] - coord_1[1]) ** 2)
                            UCS_losses[i] = cur_fit
                            # if(UCS_losses[i] < min_loss):
                                # min_loss = UCS_losses[i]
                            break
        self.best_solution = UCS_solutions[ UCS_losses.index(min(UCS_losses)) ]
        self.fitness_list.append(self.fitness(self.best_solution))

        return self.best_solution, self.fitness_list