# functions for future use

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Function to import and resize images
def load_prepare_images(filename, img_shape=224, scale=True):
    """[summary]

    Args:
        filename ([type]): [description]
        img_shape (int, optional): [description]. Defaults to 224.
        scale (bool, optional): [description]. Defaults to True.
    """
    img = tf.io.read_file(filename)
    img = tf.image.decode_jpeg(image)
    img = tf.image.resize(img, [img_shape, img_shape])
    if scale:
        return img/255.
    else:
        return img


# Function to plot a confusion matrix
import numpy as np 
import matplotlib.pyplot as plt
import itertools
from sklearn.metrics import confusion_matrix
def create_confusion_matrix(y_true, y_pred, classes=None, figsize=(10, 10), text_size=15, norm=False, savefig=False):
    """[summary]

    Args:
        y_true ([type]): [description]
        y_pred ([type]): [description]
        classes ([type], optional): [description]. Defaults to None.
        figsize ([type], optional): [description]. Defaults to (10, 10).
        text_size (int, optional): [description]. Defaults to 15.
        norm (bool, optional): [description]. Defaults to False.
        savefig (bool, optional): [description]. Defaults to False.

    Returns:
        [type]: [description]
    """
    # Compute confusion matrix
    cm = confusion_matrix(y_true, y_pred)
    cm_norm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
    n_classes = cm.shape[0]

    # Plot confusion matrix 
    fig, ax = plt.subplots(figsize=figsize)
    cax = ax.matshow(cm, cmap=plt.cm.Blues)
    fig.colorbar(cax)
    if classes: 
        labels = classes
    else:
        labels = np.arange(cm.shap[0])
    ax.set(title="Confusion Matrix",
           ylabel="True label",
           xlabel="Predicted label",
           xticks = np.arange(n_classes),
           yticks = np.arange(n_classes),
           xticklabels = labels,
           yticklabels = labels)   

    ax.xaxis.set_label_position('bottom')
    ax.xaxis.tick_bottom()
    threshold = (cm.max() + cm.min()) / 2.

    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        if norm:
            plt.text(j, i, f"{cm[i, k]*100:.1f}%",
                     horizontalalignment="center",
                     color="white" if cm[i, j] > threshold else "black",
                     size=text_size)

        else:
            plt.text(j, i, f"{cm[i, j]}",
                    horizontalalignment="center",
                    color="white" if cm[i, j] > threshold else "black",
                    size=text_size)

    if savefig:
        fig.savefig("confusion_matrix.png")


# Function to predict images and plot
def pred_plot(model, filename, class_names):
    img = load_prepare_images(filename)
    pred = model.predict(tf.expand_dims(img, axis=0))

    if len(pred[0]) > 1:
        pred_class = class_names[pred.argmax()]
    else:
        pred_class = class_names[int(tf.round(pred)[0][0])]
        
    plt.imshow(img)
    plt.title(f"Prediction: {pred_class}")
    plt.axis(False);

import datetime

def create_tensorboard_callback(dir_name, experiment_name):
    log_dir = dir_name + "/" + experiment_name + "/" +datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
    tensorboard_callback = tf.keras.callbacks.TensorBoard(
        log_dir=log_dir
    )
    print(f"Saved Tensorboard logs to: {log_dir}")  
    return tensorboard_callback

# Function to plot validation and training separately
import matplotlib.pyplot as plt

def plot_loss_curves(history):
    loss = history.history["loss"]
    val_loss = history.history["val_loss"]
    accuracy = history.history["accuracy"]
    val_accuracy = history.history["val_accuracy"]
    epochs = range(len(history.history["loss]"]))

    plt.plot(epochs, loss, label="Training_loss")
    plt.plot(epochs, val_loss, label="Validation_loss")
    plt.title("Loss")
    plt.xlabel("Epochs")
    plt.legend()

    plt.figure()
    plt.plot(epochs, accuracy, label="Training_accuracy")
    plt.plot(epochs, val_accuracy, label="Validation_accuracy")
    plt.title("Accuracy")
    plt.xlabel("Epochs")
    plt.legend();

def compare_history(original_history, new_history, inital_epochs=5):
    acc = original_history.history["accuracy"]
    loss = original_history.history["loss"]
    val_acc = original_history.history["val_accuracy"]
    val_loss = original_history.history["val_loss"]
    total_acc = acc + new_history.history["accuracy"]
    total_loss = loss + new_history.history["loss"]
    total_val_acc = val_acc + new_history.history["val_accuracy"]
    total_val_loss = val_loss + new_history.history["val_loss"]
    
    plt.figure(figsize=(10, 10))
    plt.subplot(2, 1, 1)
    plt.plot(total_acc, label="Training_accuracy")
    plt.plot(total_val_acc, label="Validation_accuracy")
    plt.plot([initial_epochs-1, initial_epoch-1],
              plt.ylim(), label="Start Fine Tuning")
    plt.legend(loc="lower right")
    plt.title("Training and Validation Accuracy")
    plt.subplot(2, 1, 2)
    plt.plot(total_loss, label="Training_loss")
    plt.plot(total_val_loss, label="Validation_loss")
    plt.plot([initial_epochs-1, initial_epoch-1],
              plt.ylim(), label="Start Fine Tuning")
    plt.legend(loc="upper right")
    plt.title("Training and Validation Loss")
    plt.xlabel("epoch")
    plt.show()

# Function to unzip a file
import zipfile

def unzip_data(filename):
    zip_ref = zipfile.ZipFile(filename, 'r')
    zip_ref.extractall()
    zip_ref.close()


# Function to walkthrough a directory and return a list of files
import os

def walk_dir(dir_path):
    for dirpath, dirnames, filenames in os.walk(dir_path):
        print(f"Directories {len(dirnames)} and images {len(filenames)} in '{dirpath}'. ")


# Function for evaluation, accuraccy, precision_recall_f1_score
from sklearn.metrics import accuracy_score, precision_recall_fscore_support, f1_score

def calculate_results(y_true, y_pred):
    model_accuracy = accuracy_score(y_true, y_pred) * 100
    model_precision, model_recall, model_f1, _ = precision_recall_fscore_support(y_true, y_pred, average="weighted")
    model_results = {"accuracy": model_accuracy,
                     "precision": model_precision,
                     "recall": model_recall,
                     "f1": model_f1}
    return model_results