chatbot.py

import streamlit as st
from groq import Groq
from langchain_groq import ChatGroq
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from html import escape
import edge_tts
import asyncio
import os

GROQ_API_KEY = os.getenv('GROQ_API_KEY')

class CodeAssistantBot:
    def __init__(self):
        self.client = Groq(api_key=GROQ_API_KEY)
        self.model = ChatGroq(model="llama-3.3-70b-versatile", temperature=0.6)
        self.analysis_prompt = ChatPromptTemplate.from_messages([
            ("system",
             "You are a skilled coding assistant. Use the following context and user input to help."
             " Refer to previous summary and recent interactions to make answers accurate."
             " Keep your response short, relevant, and conversational — smaller is better if it covers what's needed."),
            ("user",
             "Code: {code}\nOutput: {output}\nError: {error}\n"
             "Summary: {summary}\nRecent: {recent}\nQuestion: {question}")
        ])
        self.summary_prompt = ChatPromptTemplate.from_messages([
            ("system", "Summarize key technical points from the conversation so far."),
            ("user", "Conversation: {conversation}")
        ])

    def analyze_code(self, code, output, error, question, summary="", history=None):
        try:
            parser = StrOutputParser()
            recent = "\n".join([f"User: {q}\nBot: {a}" for q, a in (history or [])[-4:]])
            chain = self.analysis_prompt | self.model | parser
            return chain.invoke({
                'code': code,
                'output': output,
                'error': error,
                'summary': summary,
                'recent': recent,
                'question': question
            })
        except Exception as e:
            return f"Error: {e}"

async def text_to_speech(text, filename):
    voice = "fr-FR-VivienneMultilingualNeural"
    await edge_tts.Communicate(text, voice).save(filename)

def render_chatbot(code, output, error):
    """Render the chatbot UI with code-block support and a scrollable chat container."""

    # Style
    st.markdown("""
    <style>
    .chat-container {
        max-height: 60vh;
        overflow-y: auto;
        padding-right: 0.5rem;
        border: 1px solid #ddd;
        border-radius: 8px;
        margin-top: 1rem;
        padding: 1rem;
        background-color: #f9f9f9;
    }
    .chat-message {
        margin-bottom: 1rem;
        word-wrap: break-word;
    }
    .user-message {
        font-weight: bold;
        color: #1a73e8;
    }
    .bot-message pre {
        background-color: #f0f0f0;
        padding: 0.5rem;
        border-radius: 5px;
        overflow-x: auto;
    }
    </style>
    """, unsafe_allow_html=True)

    # Session state setup
    st.session_state.setdefault('conversation', [])
    st.session_state.setdefault('audio_count', 0)
    st.session_state.setdefault('chat_summary', "")
    st.session_state.setdefault('chat_display_count', 5)

    # Input UI
    c1, c2 = st.columns([4, 1], gap='small')
    with c1:
        question = st.text_input("Ask your question…", key="chat_input")
    with c2:
        send = st.button("🚀")

    # Process question
    if send and question:
        bot = CodeAssistantBot()
        history = st.session_state.conversation[-4:]
        summary = st.session_state.chat_summary

        response = bot.analyze_code(code, output, error, question, summary, history)

        st.session_state.conversation.append((question, response))
        st.session_state.chat_display_count = 5  # Reset visible count for new message

        # Update summary (based on last 10 entries)
        if len(st.session_state.conversation) >= 3:
            try:
                full_chat = "\n".join([f"User: {q}\nBot: {a}" for q, a in st.session_state.conversation[-10:]])
                parser = StrOutputParser()
                summarizer = bot.summary_prompt | bot.model | parser
                st.session_state.chat_summary = summarizer.invoke({'conversation': full_chat})
            except:
                pass  # Don't fail on summary issues

    # Display conversation (newest at top, paginated)
    total_messages = len(st.session_state.conversation)
    start_idx = max(0, total_messages - st.session_state.chat_display_count)
    visible_conversation = st.session_state.conversation[start_idx:]

    # Newest first
    for q, a in reversed(visible_conversation):
        st.markdown(f'<div class="chat-message user-message">{escape(q)}</div>', unsafe_allow_html=True)

        def format_response(text):
            parts = text.split('```')
            result = ''
            for i, part in enumerate(parts):
                if i % 2 == 1:
                    lines = part.splitlines()
                    if lines and lines[0].isalpha():
                        lines = lines[1:]
                    code_html = escape("\n".join(lines))
                    result += f'<pre><code>{code_html}</code></pre>'
                else:
                    result += escape(part)
            return result

        formatted = format_response(a)
        st.markdown(f'<div class="chat-message bot-message">{formatted}</div>', unsafe_allow_html=True)

    if start_idx > 0:
        if st.button("🔽 Show more"):
            st.session_state.chat_display_count += 5
            st.rerun()

    # Auto-scroll (optional)
    st.markdown("""
    <script>
    const c = window.parent.document.querySelector('.chat-container');
    if (c) c.scrollTop = c.scrollHeight;
    </script>
    """, unsafe_allow_html=True)