from dotenv import load_dotenv
import openai

load_dotenv()

import streamlit as st
from youtube_transcript_api import YouTubeTranscriptApi
import os

# Function to get the transcript from a YouTube video
def get_transcript(video_id):
    try:
        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
        transcript_text = ' '.join([entry['text'] for entry in transcript_list])
        return transcript_text
    except Exception as e:
        return str(e)
    
def get_youtube_thumbnail_url(video_id):
    thumbnail_url = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
    return thumbnail_url

    # Construct the thumbnail URL
    thumbnail_url = f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"
    return thumbnail_url

# Function to summarize video transcript
#def summarize_transcript(text):
   # response = openai.completions.create(
     #   model="gpt-3.5-turbo-instruct",
    #    prompt="Summarize this video transcript in hundred words, ensuring it ends with a complete sentence and a period" + text,
    #    max_tokens=300,
   #     temperature=0.5,
   # )
   # return response.choices[0].text.strip()

def chunk_transcript(transcript, chunk_size=4000):
    """Divides the transcript into manageable chunks."""
    words = transcript.split()
    chunks = []
    current_chunk = []
    current_length = 0
    
    for word in words:
        current_chunk.append(word)
        current_length += len(word) + 1  # Adding 1 for space
        if current_length >= chunk_size:
            chunks.append(' '.join(current_chunk))
            current_chunk = []
            current_length = 0
            
    # Add the last chunk if it's not empty
    if current_chunk:
        chunks.append(' '.join(current_chunk))
    
    return chunks

def summarize_chunk(chunk):
    """Summarizes a single chunk of text."""
    prompt = f"Summarize this part of youtube video transcript: {chunk}"
    response = openai.completions.create(
        model="gpt-3.5-turbo-instruct",
        prompt=prompt,
        max_tokens=300,  # Adjust as needed
        temperature=0.5
    )
    return response.choices[0].text.strip()

def summarize_final_summary(final_summary):
    """Summarizes a single chunk of text."""
    prompt = (f"Given these summaries of different parts of a YouTube video transcript, "
            f"provide a comprehensive summary that encapsulates all key points:{final_summary}"
              f"Create a coherent summary that captures the essence of the entire video content."
              f"Ensure the summary starts and ends with a complete sentence and ends with a period.")
    response = openai.completions.create(
        model="gpt-3.5-turbo-instruct",
        prompt=prompt,
        max_tokens=300,  # Adjust as needed
        temperature=0.6
    )
    return response.choices[0].text.strip()

def synthesize_summaries(summaries):
    """Synthesizes chunk summaries into a final summary."""
    combined_summary = ' '.join(summaries)
    # You might want to summarize again if the combined summary is too long
    return combined_summary

def summarize_transcript(transcript):
    chunks = chunk_transcript(transcript)
    chunk_summaries = [summarize_chunk(chunk) for chunk in chunks]
    final_summary = synthesize_summaries(chunk_summaries)
    finalworded_summary = summarize_final_summary(final_summary)
    return finalworded_summary


# Streamlit app layout
st.set_page_config(page_title="YouTube Video Summarizer")
st.title("YouTube Video Summarizer")

# Input for YouTube video URL
url = st.text_input("Enter YouTube video URL:", "")

if url:
    # Extract video ID from URL
    video_id_param = url.split('v=')
    # Correction: Properly extract video_id from video_id_param
    video_id = video_id_param[1].split("&")[0] if len(video_id_param) > 1 else None
    
    if video_id:
        # Display Thumbnail
        thumbnail_url = get_youtube_thumbnail_url(video_id)
        st.image(thumbnail_url, caption="Video Thumbnail",width=300, use_column_width=True)
        
        # Get transcript
        transcript = get_transcript(video_id)
        
        if transcript:
            # Display Transcript
            if st.checkbox("Show Transcript"):
                st.text_area("Transcript", value=transcript, height=300)

            # Button to trigger summarization
            if st.button("Summarize"):
                with st.spinner('Generating summary...'):
                    summary = summarize_transcript(transcript)                
                    st.subheader("Summary")
                    st.write(summary)
        else:
            st.error("Could not retrieve transcript. Make sure the video has captions enabled.")
    else:
        st.error("Invalid YouTube video URL.")
else:
    st.info("Please enter a YouTube video URL.")