app.py

import streamlit as st
import pandas as pd
import os
import tempfile
from io import BytesIO
from pdf_generator import PDFGenerator
from data_processor import DataProcessor
from template_manager import TemplateManager

# Page configuration
st.set_page_config(
    page_title="Automated PDF Export System",
    page_icon="📄",
    layout="wide"
)

def main():
    st.title("📄 Automated PDF Export System")
    st.markdown("Upload your data files and generate professional BOV reports with preserved formatting.")
    
    # Initialize session state
    if 'processed_data' not in st.session_state:
        st.session_state.processed_data = None
    if 'template_loaded' not in st.session_state:
        st.session_state.template_loaded = False
    
    # Create two columns for layout
    col1, col2 = st.columns([1, 1])
    
    with col1:
        st.header("📊 Data Upload")
        
        # File uploader
        uploaded_file = st.file_uploader(
            "Choose a data file",
            type=['csv', 'xlsx', 'xls'],
            help="Upload CSV or Excel files containing your data"
        )
        
        if uploaded_file is not None:
            try:
                with st.spinner("Processing data file..."):
                    # Process the uploaded file
                    data_processor = DataProcessor()
                    df = data_processor.load_file(uploaded_file)
                    st.session_state.processed_data = df
                    
                st.success(f"✅ File processed successfully! Found {len(df)} records.")
                
                # Show data preview
                st.subheader("Data Preview")
                st.dataframe(df.head(10), use_container_width=True)
                
                # Show column information
                st.subheader("Column Information")
                col_info = pd.DataFrame({
                    'Column': df.columns,
                    'Data Type': df.dtypes,
                    'Non-Null Count': df.count(),
                    'Sample Value': [str(df[col].iloc[0]) if len(df) > 0 else 'N/A' for col in df.columns]
                })
                st.dataframe(col_info, use_container_width=True)
                
            except Exception as e:
                st.error(f"❌ Error processing file: {str(e)}")
                st.session_state.processed_data = None
    
    with col2:
        st.header("📋 Template Management")
        
        # Template selection
        template_manager = TemplateManager()
        available_templates = template_manager.get_available_templates()
        
        selected_template = st.selectbox(
            "Select BOV Template",
            available_templates,
            help="Choose a pre-formatted template for your PDF export"
        )
        
        if selected_template:
            try:
                template_content = template_manager.load_template(selected_template)
                st.session_state.template_loaded = True
                st.success(f"✅ Template '{selected_template}' loaded successfully!")
                
                # Show template preview
                st.subheader("Template Preview")
                with st.expander("View Template Structure", expanded=False):
                    st.code(template_content[:500] + "..." if len(template_content) > 500 else template_content, language="html")
                
            except Exception as e:
                st.error(f"❌ Error loading template: {str(e)}")
                st.session_state.template_loaded = False
    
    # PDF Generation Section
    st.header("🚀 PDF Generation")
    
    if st.session_state.processed_data is not None and st.session_state.template_loaded:
        col1, col2, col3 = st.columns([1, 1, 1])
        
        with col1:
            # Generation options
            st.subheader("Generation Options")
            
            # Record selection
            total_records = len(st.session_state.processed_data)
            generate_all = st.checkbox(f"Generate PDF for all {total_records} records", value=True)
            
            if not generate_all:
                record_range = st.slider(
                    "Select record range",
                    min_value=1,
                    max_value=total_records,
                    value=(1, min(10, total_records)),
                    help="Select which records to include in the PDF"
                )
            else:
                record_range = (1, total_records)
        
        with col2:
            st.subheader("PDF Settings")
            
            # PDF options
            include_images = st.checkbox("Include images", value=True)
            preserve_formatting = st.checkbox("Preserve formatting", value=True)
            page_size = st.selectbox("Page size", ["A4", "Letter", "Legal"], index=0)
        
        with col3:
            st.subheader("Output Options")
            
            # Output filename
            output_filename = st.text_input(
                "Output filename",
                value="BOV_Report.pdf",
                help="Name for the generated PDF file"
            )
            
            if not output_filename.endswith('.pdf'):
                output_filename += '.pdf'
        
        # Generate PDF button
        if st.button("🔥 Generate PDF", type="primary", use_container_width=True):
            try:
                with st.spinner("Generating PDF... This may take a moment."):
                    # Prepare data subset
                    start_idx, end_idx = record_range
                    data_subset = st.session_state.processed_data.iloc[start_idx-1:end_idx]
                    
                    # Initialize PDF generator
                    pdf_generator = PDFGenerator(
                        template_name=selected_template,
                        include_images=include_images,
                        preserve_formatting=preserve_formatting,
                        page_size=page_size
                    )
                    
                    # Generate PDF
                    pdf_buffer = pdf_generator.generate_pdf(data_subset)
                    
                    # Show success message
                    st.success(f"✅ PDF generated successfully! ({len(data_subset)} records processed)")
                    
                    # Download button
                    st.download_button(
                        label="📥 Download PDF",
                        data=pdf_buffer.getvalue(),
                        file_name=output_filename,
                        mime="application/pdf",
                        use_container_width=True
                    )
                    
                    # Show PDF stats
                    st.info(f"📊 PDF Statistics:\n"
                           f"- Records processed: {len(data_subset)}\n"
                           f"- File size: {len(pdf_buffer.getvalue())} bytes\n"
                           f"- Template used: {selected_template}")
                    
            except Exception as e:
                st.error(f"❌ Error generating PDF: {str(e)}")
                st.exception(e)
    
    else:
        st.warning("⚠️ Please upload a data file and select a template to generate PDF.")
    
    # Footer
    st.markdown("---")
    st.markdown("*Automated PDF Export System - Streamlit Application*")

if __name__ == "__main__":
    main()