from preprocessing import parse_file
from pandas import DataFrame, Series
from sys import argv
from random import seed, randint
from time import time


def get_first_solution(n, data):
    distance_sum = DataFrame(columns=["point", "distance"])
    for element in range(n):
        element_df = data.query(f"source == {element} or destination == {element}")
        distance = element_df["distance"].sum()
        distance_sum = distance_sum.append(
            {"point": element, "distance": distance}, ignore_index=True
        )
    furthest_index = distance_sum["distance"].astype(float).idxmax()
    furthest_row = distance_sum.iloc[furthest_index]
    furthest_row["distance"] = 0
    return furthest_row


def get_different_element(original, row):
    if row.source == original:
        return row.destination
    return row.source


def get_closest_element(element, data):
    element_df = data.query(f"source == {element} or destination == {element}")
    closest_index = element_df["distance"].astype(float).idxmin()
    closest_row = data.loc[closest_index]
    closest_point = get_different_element(original=element, row=closest_row)
    return Series(data={"point": closest_point, "distance": closest_row["distance"]})


def explore_solutions(solutions, data):
    closest_elements = solutions["point"].apply(func=get_closest_element, data=data)
    furthest_index = closest_elements["distance"].astype(float).idxmax()
    return closest_elements.iloc[furthest_index]


def greedy_algorithm(n, m, data):
    solutions = DataFrame(columns=["point", "distance"])
    first_solution = get_first_solution(n, data)
    solutions = solutions.append(first_solution, ignore_index=True)
    for _ in range(m):
        element = explore_solutions(solutions, data)
        solutions = solutions.append(element)
    return solutions


def get_pseudorandom_solution(n, data):
    seed(42)
    solution = data.iloc[randint(a=0, b=n)]
    return Series(data={"point": solution["destination"], "distance": 0})


def local_search(n, m, data):
    solutions = DataFrame(columns=["point", "distance"])
    first_solution = get_pseudorandom_solution(n=n, data=data)
    solutions = solutions.append(first_solution, ignore_index=True)
    for _ in range(m):
        pass
    return solutions


def execute_algorithm(choice, n, m, data):
    if choice == "greedy":
        return greedy_algorithm(n, m, data)
    elif choice == "local":
        return local_search(n, m, data)
    else:
        print("The valid algorithm choices are 'greedy' and 'local'")
        exit(1)


def show_results(solutions, time_delta):
    distance_sum = solutions["distance"].sum()
    duplicates = solutions.duplicated()
    print(solutions)
    print("Total distance: " + str(distance_sum))
    if solutions[duplicates].empty:
        print("No duplicates found")
    print("Execution time: " + str(time_delta))


def usage(argv):
    print(f"Usage: python {argv[0]} <file> <algorithm choice>")
    print("algorithm choices:")
    print("greedy: greedy algorithm")
    print("local: local search algorithm")
    exit(1)


def main():
    if len(argv) != 3:
        usage(argv)
    n, m, data = parse_file(argv[1])
    start_time = time()
    solutions = execute_algorithm(choice=argv[2], n=n, m=m, data=data)
    end_time = time()
    show_results(solutions, time_delta=end_time - start_time)


if __name__ == "__main__":
    main()