Untitled

import json
import re
from pathlib import Path
import streamlit as st
from langchain_groq import ChatGroq
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os
import json
import streamlit as st
import reveal_slides as rs  # Import the reveal_slides module
import sys

DATA_DIR = Path(__file__).parent / "data"
DATA_DIR.mkdir(exist_ok=True)


def load_json(file_path):
    if file_path.exists():
        with open(file_path, 'r') as f:
            return json.load(f)
    return {}

def save_json(data, file_path):
    with open(file_path, 'w') as f:
        json.dump(data, f, indent=2)

def get_subject_file_paths(subject):
    base_name = subject.lower().replace(' ', '_')
    return {
        'content': DATA_DIR / f"{base_name}_lesson_content.json",
        'config': DATA_DIR / f"{base_name}_slide_config.json"
    }
class SlideComponent:
    def __init__(self, content: str, config: dict, initial_state: dict):
        self.content = content
        self.config = config
        self.initial_state = initial_state

    def render(self):
        return rs.slides(
            self.content,
            # height=self.config.get('height', 600),
            height=self.config.get('height', '100%'),
            theme=self.config.get('theme', 'black'),
            config=self.config,
            initial_state=self.initial_state,
            markdown_props={"data-separator-vertical": "^--$"},
            key=f"slides_{self.config.get('base_font_size', 24)}_{self.config.get('heading_scale', 1.5)}"
        )


class LessonPresenter:
    def __init__(self, content: dict):
        self.content = content
        self.set_subject_content(None)
        self.callback_func = None  # Callback function placeholder

    def set_subject_content(self, subject: str):
        if subject is None:
            self.subject = {"subject": "Unknown", "lessons": []}
            return

        for s in self.content.get("subjects", []):
            if s.get("subject", "").lower() == subject.lower():
                self.subject = s
                return
        print(f"Warning: Subject '{subject}' not found in JSON data")
        self.subject = {"subject": "Unknown", "lessons": []}

    def json_to_slides(self) -> str:
        subject_name = self.subject.get('subject', 'Unknown Subject')
        slides = f"# Subject Matter: {subject_name}\nPresentation By ClassPilot\n---\n"
        
        for lesson in self.subject.get("lessons", []):
            slides += f"## {lesson.get('title', 'Untitled Lesson')}\n---\n"
            for page in lesson.get("pages", []):
                slides += f"\n### {page.get('title', 'Untitled Page')}\n"
                for subtitle in page.get("subtitles", []):
                    slides += f"#### {subtitle}\n"
                slides += f"{page.get('content', '')}\n---\n"
        
        if not self.subject.get("lessons"):
            slides += "## No lessons available for this subject\n---\n"
        
        slides += "# End\n## Good Luck!"
        return slides

    def update_page(self, selected_lesson: str, selected_page: str, new_title: str, new_subtitles: str, new_content: str) -> bool:
        lesson_data = next((l for l in self.subject.get("lessons", []) if l["title"] == selected_lesson), None)
        if lesson_data:
            page_data = next((p for p in lesson_data.get("pages", []) if p["title"] == selected_page), None)
            if page_data:
                page_data["title"] = new_title
                page_data["subtitles"] = new_subtitles.split("\n")
                page_data["content"] = new_content
                
                # Save the updated content
                # if self.save_content(self.content.get("subjects")[0].get("subject")):
                if self.save_content("python"):
                    # Call the callback function if provided
                    if self.callback_func:
                        self.callback_func(self.content)
                    return True
        return False

    def set_callback_func(self, func):
        self.callback_func = func

    def create_slide_component(self, content: str, config: dict, initial_state: dict):
        full_content = self.generate_custom_css(config.get('base_font_size', 24), config.get('heading_scale', 1.5)) + content
        return SlideComponent(full_content, config, initial_state)

    def generate_custom_css(self, base_font_size: int, heading_scale: float) -> str:
        return f"""
        <style>
        .reveal .slides section {{
            height: 100%;
            overflow-y: auto !important;
            overflow-x: hidden !important;
        }}
        .reveal {{
            height: 100% !important;
            font-size: {base_font_size}px !important;
        }}
        .reveal .slides {{
            height: 100% !important;
        }}
        .reveal h1 {{ font-size: {base_font_size * heading_scale}px !important; }}
        .reveal h2 {{ font-size: {base_font_size * (heading_scale * 0.9)}px !important; }}
        .reveal h3 {{ font-size: {base_font_size * (heading_scale * 0.8)}px !important; }}
        .reveal p, .reveal li {{ font-size: {base_font_size}px !important; }}
        .reveal .slides section {{ color: #f0f0f0 !important; }}
        .reveal pre {{
            box-shadow: none !important;
            background-color: rgba(0,0,0,0.3) !important;
            margin: 15px 0 !important;
            padding: 10px !important;
            border-radius: 5px !important;
        }}
        .reveal pre code {{
            max-height: 400px !important;
            font-size: {base_font_size * 0.7}px !important;
            line-height: 1.3em !important;
            padding: 0 !important;
        }}
        .hljs {{ background: transparent !important; }}
        .reveal.white pre, .reveal.beige pre {{ background-color: rgba(0,0,0,0.05) !important; }}
        .reveal.white pre code, .reveal.beige pre code {{ color: #333 !important; }}
        .reveal.black pre, .reveal.league pre, .reveal.night pre {{ background-color: rgba(255,255,255,0.1) !important; }}
        .reveal.black pre code, .reveal.league pre code, .reveal.night pre code {{ color: #f0f0f0 !important; }}
        </style>
        """
    def save_content(self,name):
        path = DATA_DIR / f"{name}_lesson_content.json",
        save_json(self.content,path)
        
        current_dir = os.path.dirname(os.path.abspath(__file__))
        json_path = os.path.join(current_dir,'data', f'{name}_lesson_content.json')
        print(json_path)
        json_path = os.path.normpath(json_path)
        
        try:
            with open(json_path, 'w') as f:
                json.dump(self.content, f, indent=2)
            print("Content saved successfully")
            return True
        except Exception as e:
            print(f"Error saving content: {str(e)}")
            return False


def load_content(name):
    current_dir = os.path.dirname(os.path.abspath(__file__))
    json_path = os.path.join(current_dir, 'data', f'{name}_lesson_content.json')
    json_path = os.path.normpath(json_path)

    try:
        with open(json_path, 'r') as f:
            content = json.load(f)
        print("JSON file loaded successfully")
    except FileNotFoundError:
        print(f"Error: Could not find the file at {json_path}")
        content = {"subjects": []}
    except json.JSONDecodeError:
        print(f"Error: The file at {json_path} is not a valid JSON file")
        content = {"subjects": []}

    return content

def save_config(config):
    config_data = {
        "config": config,
    }
    current_dir = os.path.dirname(os.path.abspath(__file__))
    config_path = os.path.join(current_dir,'data', 'slide_config.json')
    config_path = os.path.normpath(config_path)
    
    with open(config_path, 'w') as f:
        json.dump(config_data, f, indent=2)

def create_editor_screen(presenter: LessonPresenter):
    st.title("Lesson Presentation System")
    subjects = [s["subject"] for s in presenter.content["subjects"]]
    selected_subject = st.sidebar.selectbox("Select Subject", subjects)
    presenter.set_subject_content(selected_subject)

    with st.expander("Edit Page Content", expanded=False):
        lessons = [l["title"] for l in presenter.subject.get("lessons", [])]
        selected_lesson = st.selectbox("Select Lesson", lessons)
        selected_lesson_data = next((l for l in presenter.subject.get("lessons", []) if l["title"] == selected_lesson), None)

        if selected_lesson_data:
            pages = [p["title"] for p in selected_lesson_data.get("pages", [])]
            selected_page = st.selectbox("Select Page", pages)
            selected_page_data = next((p for p in selected_lesson_data.get("pages", []) if p["title"] == selected_page), None)

            if selected_page_data:
                new_title = st.text_input("Edit Page Title", selected_page_data["title"])
                new_subtitles = st.text_area("Edit Subtitles (one per line)", "\n".join(selected_page_data.get("subtitles", [])))
                new_content = st.text_area("Edit Page Content", selected_page_data["content"], height=300)
                
                if st.button("Update Page"):
                    if presenter.update_page(selected_lesson, selected_page, new_title, new_subtitles, new_content):
                        st.success("Page updated and saved successfully!")
                        st.rerun()
                    else:
                        st.error("Failed to update and save page. Please check your input.")

    st.sidebar.header("Slide Design")
    config = {
        "base_font_size": st.sidebar.number_input("Base Font Size (px)", value=24, min_value=10, max_value=50, step=1),
        "heading_scale": st.sidebar.slider("Heading Scale", min_value=1.0, max_value=3.0, value=1.5, step=0.1),
        "theme": st.sidebar.selectbox("Theme", ["black", "white", "league", "beige", "sky", "night", "serif", "simple", "solarized"], index=0),
        "height": st.sidebar.number_input("Container Height", value=600, step=50),
        "scrollable": True,
    }
    if st.sidebar.button("Finish"):
        save_config(config)
        presenter.save_content("zibi")
        st.sidebar.success("Configuration saved successfully!")
        st.rerun()

    slides_component = presenter.create_slide_component(presenter.json_to_slides(), config, initial_state={})
    slides_component.render()
    


class LessonContentGenerator:
    def __init__(self, api_key):
        self.llm = ChatGroq(api_key=api_key)

    def generate_content(self, subject, num_lessons, pages_per_lesson, subtitles_per_page, sentences_per_page):
        prompt_template = PromptTemplate(
            input_variables=["subject", "num_lessons", "pages_per_lesson", "subtitles_per_page", "sentences_per_page"],
            template="""
            Create a detailed lesson plan on the subject of {subject}. 
            Provide EXACTLY the following:
            1. {num_lessons} lesson titles
            2. For each lesson, EXACTLY {pages_per_lesson} page titles
            3. For each page, EXACTLY {subtitles_per_page} subtitles
            4. For each page, a content summary of EXACTLY {sentences_per_page} sentences

            Format your response as a JSON structure with the following format:
            {{
            "subject": "{subject}",
            "lessons": [
                {{
                    "title": "Lesson Title",
                    "pages": [
                        {{
                            "title": "Page Title",
                            "subtitles": ["Subtitle 1", "Subtitle 2", ...],
                            "content": "Detailed content for the page (EXACTLY {sentences_per_page} sentences)"
                        }},
                        ...
                    ]
                }},
                ...
            ]
            }}

            Ensure the content is informative, relevant to the subject of {subject}, and follows this exact JSON structure. 
            Do not use any backslashes in the JSON keys.
            IMPORTANT: Strictly adhere to the numbers provided: {num_lessons} lessons, {pages_per_lesson} pages per lesson, {subtitles_per_page} subtitles per page, and {sentences_per_page} sentences per page.
            """
        )
        
        chain = LLMChain(llm=self.llm, prompt=prompt_template)
        result = chain.invoke({
            "subject": subject,
            "num_lessons": num_lessons,
            "pages_per_lesson": pages_per_lesson,
            "subtitles_per_page": subtitles_per_page,
            "sentences_per_page": sentences_per_page
        })
        
        return self._process_content(result['text'], subject, num_lessons, pages_per_lesson, subtitles_per_page, sentences_per_page)

    def _process_content(self, content, subject, num_lessons, pages_per_lesson, subtitles_per_page, sentences_per_page):
        try:
            content = json.loads(content)
            processed_content = {
                "subject": subject,
                "lessons": []
            }
            
            for i in range(num_lessons):
                lesson = content['lessons'][i] if i < len(content['lessons']) else {"title": f"Lesson {i+1}", "pages": []}
                processed_lesson = {
                    "title": lesson['title'],
                    "pages": []
                }
                
                for j in range(pages_per_lesson):
                    page = lesson['pages'][j] if j < len(lesson.get('pages', [])) else {"title": f"Page {j+1}", "subtitles": [], "content": ""}
                    processed_page = {
                        "title": page['title'],
                        "subtitles": page.get('subtitles', [])[:subtitles_per_page],
                        "content": '. '.join(page.get('content', '').split('.')[:sentences_per_page]) + '.'
                    }
                    
                    while len(processed_page['subtitles']) < subtitles_per_page:
                        processed_page['subtitles'].append(f"Subtitle {len(processed_page['subtitles'])+1}")
                    
                    processed_lesson['pages'].append(processed_page)
                
                processed_content['lessons'].append(processed_lesson)
            
            return json.dumps(processed_content, indent=2)
        except json.JSONDecodeError:
            raise ValueError("The generated content is not valid JSON.")
        except Exception as e:
            raise Exception(f"An error occurred while processing the content: {str(e)}")

class ContentEditor:
    def __init__(self, llm):
        self.llm = llm

    def expand_content(self, subtitle, page_title, content):
        prompt = PromptTemplate(
            input_variables=["subtitle", "page_title", "content"],
            template="Expand on '{subtitle}' in the context of {page_title}. Original content: {content}"
        )
        chain = LLMChain(llm=self.llm, prompt=prompt)
        expanded_content = chain.invoke({
            "subtitle": subtitle,
            "page_title": page_title,
            "content": content
        })
        return expanded_content['text']

    def summarize_content(self, page_title, summary_length, content):
        prompt = PromptTemplate(
            input_variables=["page_title", "summary_length", "content"],
            template="Summarize the content about {page_title} in a {summary_length} summary. Original content: {content}"
        )
        chain = LLMChain(llm=self.llm, prompt=prompt)
        summarized_content = chain.invoke({
            "page_title": page_title,
            "summary_length": summary_length.lower(),
            "content": content
        })
        return summarized_content['text']

class App:
    def __init__(self, api_key,isTeacher=True):
        self.generator = LessonContentGenerator(api_key)
        self.editor = ContentEditor(ChatGroq(api_key=api_key))
        self.lessonPresentor = None
    def run(self,isTeacher=True):
        st.set_page_config(layout="wide")
        
        if 'current_page' not in st.session_state:
            st.session_state.current_page = "home"
        
        if st.session_state.current_page == "home":
            self._show_home_page()
        elif st.session_state.current_page == "edit":
            content = load_content("python")
            self.lessonPresentor = LessonPresenter(content)
            create_editor_screen(self.lessonPresentor)
        else:
            self._show_editor_page()

    def _show_home_page(self):
        st.title("Home Page")
        st.write("Welcome to the Interactive Lesson Content Editor!")
        
        if st.button("Create New Lesson Content"):
            st.session_state.current_page = "editor"
            st.session_state.content_generated = False
            st.session_state.json_content = {"subject": "", "lessons": []}
            st.rerun()
        
        # Display saved lesson contents
        saved_files = Path('.').glob('*_lesson_content.json')
        for file in saved_files:
            if st.button(f"Edit {file.stem}"):
                with open(file, 'r') as f:
                    st.session_state.json_content = json.load(f)
                st.session_state.content_generated = True
                st.session_state.current_page = "editor"
                st.rerun()

    def _show_editor_page(self):
        st.markdown("""
        <div style="display: flex; justify-content: space-between; align-items: center;">
            <h1 style="margin: 0;">Interactive Lesson Content Editor</h1>
            <div id="restart-button-container"></div>
        </div>
        """, unsafe_allow_html=True)

        if 'json_content' not in st.session_state:
            st.session_state.json_content = {"subject": "", "lessons": []}
        if 'content_generated' not in st.session_state:
            st.session_state.content_generated = False

        if st.session_state.content_generated:
            self._show_restart_button()
            self._handle_content_editing()
        else:
            self._handle_content_generation()

    def _show_restart_button(self):
        if st.button("Restart and select a new subject"):
            st.session_state.clear()
            st.rerun()

    def _handle_content_generation(self):
        subject = st.text_input("Enter the subject for the lesson content:")
        col1, col2 = st.columns(2)
        with col1:
            num_lessons = st.number_input("Number of lesson titles:", min_value=1, value=2, step=1)
            pages_per_lesson = st.number_input("Pages per lesson:", min_value=1, value=2, step=1)
        with col2:
            subtitles_per_page = st.number_input("Subtitles per page:", min_value=1, value=3, step=1)
            sentences_per_page = st.number_input("Sentences per page:", min_value=1, value=3, step=1)

        if subject and subject != st.session_state.json_content.get("subject", ""):
            if st.button("Generate Content"):
                with st.spinner("Generating lesson content..."):
                    try:
                        generated_content = self.generator.generate_content(
                            subject, num_lessons, pages_per_lesson, subtitles_per_page, sentences_per_page
                        )
                        st.session_state.json_content = json.loads(generated_content)
                        st.session_state.content_generated = True
                        st.success("Lesson content generated successfully!")
                        st.rerun()
                    except Exception as e:
                        st.error(f"An error occurred: {str(e)}. Please try again.")

    def _handle_content_editing(self):
        if not st.session_state.json_content.get("lessons"):
            st.warning("No lessons available. Please generate content first.")
            return

        st.header("Lesson Content Editor")
        _, _, page_title, page = self._select_lesson_and_page()

        st.subheader(f"📝 Content: {page_title}")
        with st.expander("View original content", expanded=True):
            st.write(page.get("content", "No content available."))

        with st.expander("View subtitles"):
            for subtitle in page.get("subtitles", []):
                st.write(f"• {subtitle}")

        st.subheader("🛠️ Edit Content")
        action = st.radio("What would you like to do with the content?", ["Accept", "Expand", "Summarize"])

        if action == "Accept":
            st.success("Content accepted without changes.")
        elif action == "Expand":
            self._handle_expand_action(page, page_title)
        elif action == "Summarize":
            self._handle_summarize_action(page, page_title)

        col1, col2 = st.columns(2)
        with col1:
            if st.button("Save Changes"):
                self._save_changes()
        with col2:
            if st.button("Next Step"):
                self._save_changes()
                st.session_state.current_page = "edit"
                st.rerun()

    def _select_lesson_and_page(self):
        col1, col2 = st.columns(2)
        with col1:
            lesson_titles = [lesson.get("title", f"Lesson {i+1}") for i, lesson in enumerate(st.session_state.json_content["lessons"])]
            lesson_title = st.selectbox("📚 Select a lesson", lesson_titles)
            lesson_index = lesson_titles.index(lesson_title)
            lesson = st.session_state.json_content["lessons"][lesson_index]

        with col2:
            if not lesson.get("pages"):
                st.warning(f"No pages available for lesson: {lesson_title}")
                return None, None, None, None

            page_titles = [page.get("title", f"Page {i+1}") for i, page in enumerate(lesson["pages"])]
            page_title = st.selectbox("📄 Select a page", page_titles)
            page_index = page_titles.index(page_title)
            page = lesson["pages"][page_index]

        return lesson_title, lesson, page_title, page

    def _handle_expand_action(self, page, page_title):
        subtitles = page.get("subtitles", [])
        if subtitles:
            subtitle = st.selectbox("Select a subtitle to expand", subtitles)
            if st.button("Expand Content"):
                with st.spinner("Expanding content..."):
                    expanded_content = self.editor.expand_content(subtitle, page_title, page.get("content", ""))
                    st.subheader("Expanded Content")
                    st.write(expanded_content)
                    page["content"] = expanded_content
                    st.success("Content expanded successfully!")
        else:
            st.warning("No subtitles available for expansion.")

    def _handle_summarize_action(self, page, page_title):
        summary_length = st.select_slider("Select summary length", options=["Short", "Medium", "Long"])
        if st.button("Summarize Content"):
            with st.spinner("Summarizing content..."):
                summarized_content = self.editor.summarize_content(page_title, summary_length, page.get("content", ""))
                st.subheader("Summarized Content")
                st.write(summarized_content)
                page["content"] = summarized_content
                st.success("Content summarized successfully!")

    def _save_changes(self):
        filename = f'{st.session_state.json_content["subject"].replace(" ", "_").lower()}_lesson_content.json'
        with open(filename, 'w') as f:
            json.dump(st.session_state.json_content, f, indent=2)
        st.success(f"Changes saved successfully to {filename}!")


if __name__ == "__main__":
    api_key = ""
    
    #debug
    app = App(api_key,True)
    app.run()