import numpy as np
import seaborn as sns
import random
import matplotlib.pyplot as plt
import pprint

def calculate_similarities(products):
    """Calculate the similarity measures between all pairs of products.
    
    Parameters
    ----------
    products : list
        A list of dictionaries containing the attributes of the products.
    
    Returns
    -------
    euclidean_similarities : numpy array
        An array containing the Euclidean distance between each pair of products.
    manhattan_distances : numpy array
        An array containing the Manhattan distance between each pair of products.
    cosine_similarities : numpy array
        An array containing the cosine similarity between each pair of products.
    jaccard_similarities : numpy array
        An array containing the Jaccard index between each pair of products.
    pearson_similarities : numpy array
        An array containing the Pearson correlation coefficient between each pair of products.
    """
    # Initialize arrays to store the similarity measures
    euclidean_similarities = np.zeros((len(products), len(products)))
    manhattan_distances = np.zeros((len(products), len(products)))
    cosine_similarities = np.zeros((len(products), len(products)))
    jaccard_similarities = np.zeros((len(products), len(products)))
    pearson_similarities = np.zeros((len(products), len(products)))

    # Calculate all the similarity measures in a single loop
    for i in range(len(products)):
        for j in range(i+1, len(products)):
            p1 = products[i]['attributes']
            p2 = products[j]['attributes']

            # Calculate Euclidean distance
            euclidean_similarities[i][j] = distance.euclidean(p1, p2)
            euclidean_similarities[j][i] = euclidean_similarities[i][j]

            # Calculate Manhattan distance
            manhattan_distances[i][j] = distance.cityblock(p1, p2)
            manhattan_distances[j][i] = manhattan_distances[i][j]

            # Calculate cosine similarity
            cosine_similarities[i][j] = cosine_similarity([p1], [p2])[0][0]
            cosine_similarities[j][i] = cosine_similarities[i][j]

            # Calculate Jaccard index
            jaccard_similarities[i][j] = jaccard_similarity(p1, p2)
            jaccard_similarities[j][i] = jaccard_similarities[i][j]

            # Calculate Pearson correlation coefficient
            pearson_similarities[i][j] = np.corrcoef(p1, p2)[0][1]
            pearson_similarities[j][i] = pearson_similarities[i][j]
            
    return euclidean_similarities, manhattan_distances, cosine_similarities, jaccard_similarities, pearson_similarities

def plot_similarities(similarities_list, labels, titles):
    """Plot the given similarities as heatmaps in subplots.
    
    Parameters
    ----------
    similarities_list : list of numpy arrays
        A list of arrays containing the similarities between the products.
    labels : list
        A list of strings containing the labels for the products.
    titles : list
        A list of strings containing the titles for each plot.
    
    Returns
    -------
    None
        This function does not return any values. It only plots the heatmaps.
    """
    # Set up the plot
    fig, ax = plt.subplots(nrows=1, 
                           ncols=len(similarities_list), figsize=(6*len(similarities_list), 6/1.680))

    for i, similarities in enumerate(similarities_list):
        # Plot the heatmap
        sns.heatmap(similarities, xticklabels=labels, yticklabels=labels, ax=ax[i])
        ax[i].set_title(titles[i])
        ax[i].set_xlabel("Product")
        ax[i].set_ylabel("Product")
    
    # Show the plot
    plt.show()

# Define the products and their attributes
products = [
    {'name': 'Product 1', 'attributes': random.sample(range(1, 11), 5)},
    {'name': 'Product 2', 'attributes': random.sample(range(1, 11), 5)},
    {'name': 'Product 3', 'attributes': random.sample(range(1, 11), 5)},
    {'name': 'Product 4', 'attributes': random.sample(range(1, 11), 5)},
    {'name': 'Product 5', 'attributes': random.sample(range(1, 11), 5)}
]

pprint.pprint(products)

euclidean_similarities, manhattan_distances, \
cosine_similarities, jaccard_similarities, \
pearson_similarities = calculate_similarities(products)

# Set the labels for the x-axis and y-axis
product_labels = [product['name'] for product in products]

# List of similarity measures and their titles
similarities_list = [euclidean_similarities, cosine_similarities, pearson_similarities, 
                     jaccard_similarities, manhattan_distances]
titles = ["Euclidean Distance", "Cosine Similarity", "Pearson Correlation Coefficient", 
          "Jaccard Index", "Manhattan Distance"]

# Plot the heatmaps
plot_similarities(similarities_list, product_labels, titles)