from huggingface_hub import InferenceClient
#STEP 1 from Semantic Search (import libraries)
from sentence_transformers import SentenceTransformer
import torch

import gradio as gr
import random
#change of LLM below
client=InferenceClient("mistralai/Mistral-7B-Instruct-v0.2")
#STEP 2 from semantic search (read file)
# Open the physics_info.txt file in read mode with UTF-8 encoding
with open("physics_info.txt", "r", encoding="utf-8") as file:
  # Read the entire contents of the file and store it in a variable
  physics_info_text = file.read()

# Print the text below
print(physics_info_text)

#Step 3 from Semantic Search (chunk data)
def preprocess_text(text):
  # Strip extra whitespace from the beginning and the end of the text
  cleaned_text = text.strip()

  # Split the cleaned_text by every newline character (\n)
  chunks = cleaned_text.split(".")

  # Create an empty list to store cleaned chunks
  cleaned_chunks = []

  # Write your for-in loop below to clean each chunk and add it to the cleaned_chunks list
  for chunk in chunks:
    stripped_chunk = chunk.strip()
    if len(stripped_chunk) >= 0:
      cleaned_chunks.append(stripped_chunk)

  # Print cleaned_chunks
  print(cleaned_chunks)

  # Print the length of cleaned_chunks
  print(len(cleaned_chunks))

  # Return the cleaned_chunks
  return cleaned_chunks

# Call the preprocess_text function and store the result in a cleaned_chunks variable
cleaned_chunks = preprocess_text(physics_info_text)

# Load the pre-trained embedding model that converts text to vectors
model = SentenceTransformer('all-MiniLM-L6-v2')

#STEP 4 from Semantic Search - (embed chunks)
def create_embeddings(text_chunks):
  # Convert each text chunk into a vector embedding and store as a tensor
  chunk_embeddings = model.encode(text_chunks, convert_to_tensor=True) # Replace ... with the text_chunks list

  # Print the chunk embeddings
  print(chunk_embeddings)

  # Print the shape of chunk_embeddings
  print(chunk_embeddings.shape) # no parentheses on .shape because it's a property, not a method! Look up the difference between class methods and classes properties.

  # Return the chunk_embeddings
  return chunk_embeddings

# Call the create_embeddings function and store the result in a new chunk_embeddings variable
chunk_embeddings = create_embeddings(cleaned_chunks)

#Step 5 from semantic search (find and print top chunks)
# Define a function to find the most relevant text chunks for a given query, chunk_embeddings, and text_chunks
def get_top_chunks(query, chunk_embeddings, text_chunks):
  # Convert the query text into a vector embedding
  query_embedding = model.encode(query, convert_to_tensor=True)

  # Normalize the query embedding to unit length for accurate similarity comparison
  query_embedding_normalized = query_embedding / query_embedding.norm()

  # Normalize all chunk embeddings to unit length for consistent comparison
  chunk_embeddings_normalized = chunk_embeddings / chunk_embeddings.norm(dim=1, keepdim=True)

  # Calculate cosine similarity between query and all chunks using matrix multiplication
  similarities = torch.matmul(chunk_embeddings_normalized, query_embedding_normalized)

  # Print the similarities
  print(similarities)

  # Find the indices of the 3 chunks with highest similarity scores
  top_indices = torch.topk(similarities, k=3).indices

  # Print the top indices
  print(top_indices)

  # Create an empty list to store the most relevant chunks
  top_chunks = []

  # Loop through the top indices and retrieve the corresponding text chunks
  for index in top_indices:
    chunk = text_chunks[index]
    top_chunks.append(chunk)

  # Return the list of most relevant chunks
  return top_chunks




def respond(message, history):
    best_physics_chunks = get_top_chunks(message, chunk_embeddings, cleaned_chunks)
    print(best_physics_chunks)
    str_physics_chunks = "\n".join(best_physics_chunks)
    messages = [
        {
            "role": "system",
            "content": (
                "You are a very smart, arrogant professor who knows a lot about physics." 
                "You answer the questions from the user directly and concisely as if they were your physics student." 
                "Base your response on the provided context. Keep your answers to 100 words or less."
            )
        },
        {
            "role": "user",
            "content": (
                f"Context:\n{str_physics_chunks}\n\n"
                f"Question: {message}"
            )
        }]
        
    if history:
        messages.extend(history)

    messages.append(
        {"role": "user",
         "content": message})


    response = client.chat_completion(messages, max_tokens=100)
    print(response)
    return response['choices'][0]['message']['content'].strip()
    
chatbot = gr.ChatInterface(respond, type="messages", theme="mgetz/Celeb_glitzy", title="Physics Chatbot", description="Use this chatbot to help you with Physics")
chatbot.launch()