import numpy as np

"""
returns the euclidean distance between vector_one and vector_two
"""
def compute_euclidean_distance(vector_one, vector_two):
  return np.linalg.norm(vector_one - vector_two)

"""
image-image similarity computation
"""
def calculate_similarity(features_image1, features_image2):
  return compute_euclidean_distance(np.array(features_image1), np.array(features_image2))

"""
retains top k similar image links
"""
def top_k(graph_list, k):
  reduced_graph_file = open("reduced_graph_file_" + str(k) + ".txt", "a+")
  top_k = sorted(graph_list, key=lambda x:(-x[2], x[1], x[0]))[0:k]
  for iter in top_k:
    reduced_graph_file.write(str(iter[0]) + " " + str(iter[1]) + " " + str(iter[2]) + "\n")

"""
generate_imgximg_edgelist returns image to image similarity in form of an edge list
"""
def generate_imgximg_edgelist(image_list1, image_list2, image_feature_map, k):
  imgximg_edgelist_file = open("entire_graph_file.txt", "w")
  image_id_mapping_file = open("image_id_mapping.pickle", "wb")
  image_id_mapping = {}

  for index1 in range(0, len(image_list1)):
    local_img_img_sim_list = []
    for index2 in range(0, len(image_list2)):
      image1 = image_list1[index1]
      image2 = image_list2[index2]
      features_image1 = image_feature_map[image1]
      features_image2 = image_feature_map[image2]
      score = 1 / (1 + calculate_similarity(features_image1, features_image2))
      imgximg_edgelist_file.write(str(image1) + " " + str(image2) + " " + str(score) + "\n")
      local_img_img_sim_list.append((image1, image2, score))

    top_k(local_img_img_sim_list, k)
    image_id_mapping[image1] = index1

  pickle.dump(["Image_id mapping:", image_id_mapping], image_id_mapping_file)
  image_id_mapping_file.close()

"""
if similarity is false, adj_matrix represents connectivity between two nodes in the graph
if similarity is true, adj_matrix contains similarity between any two nodes in the graph
"""
def create_adj_mat_from_reduced_file(k, similarity=False):
  image_id_mapping_file = open("image_id_mapping.pickle", "rb")
  image_id_mapping = pickle.load(image_id_mapping_file)[1]

  graph_file = open("reduced_graph_file_" + str(k) + ".txt", "r")
  edges = graph_file.readlines()

  graph_file_len = len(edges)
  size_of_graph = graph_file_len // k
  adj_matrix = []
  image1 = ""
  for line in edges:
    temp = line.split(" ")
    if image1 != image_id_mapping[temp[0]]:
      adj_matrix.append([0]*size_of_graph)
      image1 = image_id_mapping[temp[0]]
    else:
      img2 = image_id_mapping[temp[1]]
      if(similarity):
        adj_matrix[-1][img2] = float(temp[2])
      else:
        adj_matrix[-1][img2] = 1

  return adj_matrix


k = 7
image_feature_map = prepare_dataset(mapping)
image_list = list(image_feature_map.keys())
generate_imgximg_edgelist(image_list, image_list, image_feature_map, k)
graph = create_adj_mat_from_reduced_file(k, True)