import streamlit as st
from crew_initializer import initialize_crew
from utils.pdf_generator import generate_pdf
import json
import logging
import re

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Custom JSON Encoder
class CustomJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        try:
            # Convert objects with __dict__ attributes to dictionaries
            if hasattr(obj, "__dict__"):
                return obj.__dict__
            return super().default(obj)
        except TypeError:
            return str(obj)  # Fallback for unsupported types

# Hardcoded credentials
USER_CREDENTIALS = {"username": "admin", "password": "P@ssword123"}

def authenticate_user():
    """Authenticate the user with a username and password"""
    st.sidebar.header("Login")
    username = st.sidebar.text_input("Username")
    password = st.sidebar.text_input("Password", type="password")
    
    if st.sidebar.button("Login"):
        if username == USER_CREDENTIALS["username"] and password == USER_CREDENTIALS["password"]:
            st.session_state.authenticated = True
            st.sidebar.success("Login successful!")
            st.rerun()  # Rerun to clear login form and show the app
        else:
            st.sidebar.error("Invalid username or password.")

def main():
    """
    Main entry point for the Streamlit application.
    Handles user input, executes tasks, and displays results.
    """
    # Ensure authentication state is properly initialized
    if 'authenticated' not in st.session_state:
        st.session_state.authenticated = False

    # Authenticate user if not authenticated
    if not st.session_state.authenticated:
        authenticate_user()
        return  # Exit early if not authenticated
    
    # Once authenticated, proceed with the main application
    st.title("**Company Researcher Tool**")

    st.sidebar.header("Provide Company Details")
    company_name = st.sidebar.text_input("Enter the Company URL:")

    # Show the "Run Analysis" button if the user is authenticated
    if st.session_state.authenticated:
        # Show the button whether or not the company name is entered
        run_analysis_button = st.sidebar.button("Run Analysis")

        # Only run the analysis when the button is clicked
        if run_analysis_button:
            st.markdown(f"### **Running analysis for:** {company_name}", unsafe_allow_html=True)

            with st.spinner("Executing tasks, please wait..."):
                try:
                    crew = initialize_crew()
                    result = crew.kickoff(inputs={"company": company_name})
                    result_serialized = json.loads(json.dumps(result, cls=CustomJSONEncoder))
                    
                    # Extracting the raw summary report
                    summary_report = result_serialized.get('tasks_output', [{}])[0].get('raw', '')
                    
                    # Formatting the raw content into structured report
                    structured_report = format_report(summary_report)
                    
                    st.markdown(f"### **Summary Report**", unsafe_allow_html=True)
                    st.markdown(structured_report, unsafe_allow_html=True)

                    pdf_buffer = generate_pdf(result_serialized)
                    st.download_button(
                        label="📄 Download Report (PDF)",
                        data=pdf_buffer,
                        file_name=f"{company_name}_report.pdf",
                        mime="application/pdf"
                    )
                except Exception as e:
                    logging.error(f"Error during analysis: {str(e)}")
                    st.error(f"An error occurred: {str(e)}")
    else:
        st.info("Please enter a company name to run the analysis.")

def format_report(raw_text):
    """
    Takes raw text (markdown/structured content) and formats it to 
    create a more readable, structured report with bold headers.
    """
    # This pattern looks for headings with a number followed by bold text and a colon (e.g. 1. **Heading**:)
    heading_pattern = r'(\d+\.)\s?(\*\*[^*]+\*\*):'

    # Replace headings with Markdown syntax (e.g., ## **Heading**:)
    formatted_report = re.sub(heading_pattern, r'## \2:', raw_text)

    # Replace **bold text** with proper markdown formatting
    formatted_report = re.sub(r'\*\*(.*?)\*\*', r'**\1**', formatted_report)

    # Replace **bold** with HTML <strong> to control the bolding in headers only
    formatted_report = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', formatted_report)

    # Now use Markdown for the rest of the text, with normal text not bold
    formatted_report = formatted_report.replace("\n", "<br>")  # Use line breaks for formatting

    return formatted_report


if __name__ == "__main__":
    main()