app.py

import streamlit as st
from streamlit.components.v1 import html
from pathlib import Path
import json
import time
from datetime import datetime
import re
import pandas as pd
import yaml
from io import StringIO
import openpyxl
import csv
import base64
import glob
import os

# Add this function after the imports and before other functions
def scan_and_load_files():
    """🔍 File Detective - Scans directory for supported files and loads them automatically"""
    loaded_files = []
    
    # Get all files with supported extensions
    for ext in FILE_TYPES.keys():
        files = glob.glob(f"*.{ext}")
        for filepath in files:
            try:
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()
                    file_type = filepath.split('.')[-1].lower()
                    
                    # Store file content and type
                    st.session_state.file_data[filepath] = content
                    st.session_state.file_types[filepath] = file_type
                    
                    # Special handling for markdown files
                    if file_type == 'md':
                        if filepath not in [f["filename"] for f in st.session_state.md_files_history]:
                            st.session_state.md_outline[filepath] = parse_markdown_outline(content)
                            st.session_state.rendered_content[filepath] = content
                            add_to_history(filepath, content, "auto-loaded")
                    
                    loaded_files.append(filepath)
            except Exception as e:
                st.error(f"🚨 Error loading {filepath}: {str(e)}")
    
    return loaded_files

# Modify the main function to include initial file scanning
def main():
    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
    
    # Scan for existing files on startup
    if 'files_scanned' not in st.session_state:
        loaded_files = scan_and_load_files()
        if loaded_files:
            st.success(f"🎉 Auto-loaded {len(loaded_files)} existing files: {', '.join(loaded_files)}")
        st.session_state.files_scanned = True
    
    # Show markdown history in sidebar
    show_sidebar_history()
    
    # Add tabs for different upload methods
    upload_tab, book_tab = st.tabs(["📤 File Upload", "📖 Book View"])
    
    with upload_tab:
        # Add a rescan button
        if st.button("🔄 Rescan Directory"):
            st.session_state.files_scanned = False
            st.experimental_rerun()
        
        col1, col2 = st.columns(2)
        
        with col1:
            single_uploaded_file = st.file_uploader(
                "📤 Upload single file", 
                type=list(FILE_TYPES.keys()),
                help="Supports: " + ", ".join([f"{v} (.{k})" for k, v in FILE_TYPES.items()]),
                key="single_uploader"
            )
        
        with col2:
            multiple_uploaded_files = st.file_uploader(
                "📚 Upload multiple files",
                type=list(FILE_TYPES.keys()),
                accept_multiple_files=True,
                help="Upload multiple files to view as a book",
                key="multiple_uploader"
            )
        
        # Process single file upload
        if single_uploaded_file:
            content, file_type = read_file_content(single_uploaded_file)
            if content is not None:
                st.session_state.file_data[single_uploaded_file.name] = content
                st.session_state.file_types[single_uploaded_file.name] = file_type
                st.success(f"🎉 Loaded {FILE_TYPES.get(file_type, '📄')} file: {single_uploaded_file.name}")
        
        # Process multiple file upload
        if multiple_uploaded_files:
            for uploaded_file in multiple_uploaded_files:
                content, file_type = read_file_content(uploaded_file)
                if content is not None:
                    st.session_state.file_data[uploaded_file.name] = content
                    st.session_state.file_types[uploaded_file.name] = file_type
            st.success(f"🎉 Loaded {len(multiple_uploaded_files)} files")
        
        # Show file history
        show_file_history()
        
        # Show individual files
        if st.session_state.file_data:
            st.subheader("📂 Your Files")
            for filename, content in st.session_state.file_data.items():
                file_type = st.session_state.file_types[filename]
                with st.expander(f"{FILE_TYPES.get(file_type, '📄')} {filename}"):
                    if file_type == "md":
                        content = create_markdown_tabs(content, filename)
                    else:
                        edited_content = st.text_area(
                            "Content",
                            content,
                            height=300,
                            key=f"edit_{filename}"
                        )
                        if edited_content != content:
                            st.session_state.file_data[filename] = edited_content
                            content = edited_content
                    
                    if st.button(f"💾 Save {filename}"):
                        if save_file_content(content, filename, file_type):
                            st.success(f"✨ Saved {filename} successfully!")
    
    with book_tab:
        show_book_view()

# 🎨 File type emojis - Making file types fun and visual!
FILE_TYPES = {
    "md": "📝 Markdown",
    "txt": "📄 Text",
    "json": "🔧 JSON",
    "csv": "📊 CSV",
    "xlsx": "📗 Excel",
    "yaml": "⚙️ YAML",
    "xml": "🔗 XML"
}

# 🧠 Brain initialization - Setting up our app's memory!
if 'file_data' not in st.session_state:
    st.session_state.file_data = {}
if 'file_types' not in st.session_state:
    st.session_state.file_types = {}
if 'md_outline' not in st.session_state:
    st.session_state.md_outline = {}
if 'rendered_content' not in st.session_state:
    st.session_state.rendered_content = {}
if 'file_history' not in st.session_state:
    st.session_state.file_history = []
if 'md_versions' not in st.session_state:
    st.session_state.md_versions = {}
if 'md_files_history' not in st.session_state:
    st.session_state.md_files_history = []
if 'combined_markdown' not in st.session_state:
    st.session_state.combined_markdown = ""

# 🧹 Clean Sweep! - Decluttering our markdown files
def delete_all_md_files():
    """Delete all markdown files except README.md"""
    files_to_remove = [
        f for f in st.session_state.md_files_history 
        if f["filename"] != "README.md"
    ]
    for file in files_to_remove:
        filename = file["filename"]
        if filename in st.session_state.file_data:
            del st.session_state.file_data[filename]
        if filename in st.session_state.file_types:
            del st.session_state.file_types[filename]
        if filename in st.session_state.md_outline:
            del st.session_state.md_outline[filename]
        if filename in st.session_state.rendered_content:
            del st.session_state.rendered_content[filename]
        if filename in st.session_state.md_versions:
            del st.session_state.md_versions[filename]
    
    st.session_state.md_files_history = [
        f for f in st.session_state.md_files_history 
        if f["filename"] == "README.md"
    ]
    st.session_state.combined_markdown = ""
    return len(files_to_remove)

# 🎁 Download Gift Wrapper - Making files downloadable with style!
def get_binary_file_downloader_html(bin_file, file_label='File'):
    """Generate a link allowing the data in a given file to be downloaded"""
    b64 = base64.b64encode(bin_file.encode()).decode()
    return f'<a href="data:text/plain;base64,{b64}" download="{file_label}">📥 Download {file_label}</a>'

# 🔐 Secret Keeper - Encoding our content safely
def encode_content(content):
    """Encode content to base64"""
    return base64.b64encode(content.encode()).decode()

# 🔓 Mystery Solver - Decoding our secret content
def decode_content(encoded_content):
    """Decode content from base64"""
    return base64.b64decode(encoded_content.encode()).decode()

# 📚 Book Maker - Combining markdown files into a beautiful book
def combine_markdown_files():
    """Combine all markdown files into a single document"""
    combined = []
    for md_file in sorted(st.session_state.md_files_history, key=lambda x: x["filename"]):
        content = decode_content(md_file["content"])
        combined.append(f"# {md_file['filename']}\n\n{content}\n\n---\n\n")
    return "".join(combined)

# 📝 History Scribe - Recording every file action with precision
def add_to_history(filename, content, action="uploaded"):
    """Add a file action to the history with timestamp"""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    encoded_content = encode_content(content)
    history_entry = {
        "timestamp": timestamp,
        "filename": filename,
        "action": action,
        "content": encoded_content
    }
    st.session_state.file_history.insert(0, history_entry)
    
    if filename.endswith('.md'):
        if filename not in st.session_state.md_versions:
            st.session_state.md_versions[filename] = []
        st.session_state.md_versions[filename].append({
            "timestamp": timestamp,
            "content": encoded_content,
            "action": action
        })
        
        if filename not in [f["filename"] for f in st.session_state.md_files_history]:
            st.session_state.md_files_history.append({
                "filename": filename,
                "timestamp": timestamp,
                "content": encoded_content
            })
        
        st.session_state.combined_markdown = combine_markdown_files()

# 📚 Shelf Display - Showing our markdown collection in the sidebar
def show_sidebar_history():
    """Display markdown file history in the sidebar"""
    st.sidebar.markdown("### 📚 Markdown Files History")
    
    if st.sidebar.button("🧹 Delete All (except README.md)"):
        deleted_count = delete_all_md_files()
        st.sidebar.success(f"Deleted {deleted_count} markdown files")
        st.rerun()
    
    for md_file in st.session_state.md_files_history:
        col1, col2, col3 = st.sidebar.columns([2, 1, 1])
        
        with col1:
            st.markdown(f"**{md_file['filename']}**")
        
        with col2:
            if st.button("📂 Open", key=f"open_{md_file['filename']}"):
                content = decode_content(md_file['content'])
                st.session_state.file_data[md_file['filename']] = content
                st.session_state.file_types[md_file['filename']] = "md"
                st.session_state.md_outline[md_file['filename']] = parse_markdown_outline(content)
                st.rerun()
        
        with col3:
            download_link = get_binary_file_downloader_html(
                decode_content(md_file['content']), 
                md_file['filename']
            )
            st.markdown(download_link, unsafe_allow_html=True)

# 📖 Book Display - Showing our combined markdown masterpiece
def show_book_view():
    """Display all markdown files in a book-like format"""
    if st.session_state.combined_markdown:
        st.markdown("## 📖 Book View")
        st.markdown(st.session_state.combined_markdown)

# 📋 Time Traveler - Showing our file's journey through time
def show_file_history():
    """Display the file history in a collapsible section"""
    if st.session_state.file_history:
        with st.expander("📋 File History", expanded=False):
            st.markdown("### Recent File Activities")
            for entry in st.session_state.file_history:
                col1, col2 = st.columns([2, 3])
                with col1:
                    st.markdown(f"**{entry['timestamp']}**")
                with col2:
                    st.markdown(f"{entry['action'].title()}: {entry['filename']}")

# ⏰ Time Machine - Exploring previous versions of our files
def show_markdown_versions(filename):
    """Display previous versions of a markdown file"""
    if filename in st.session_state.md_versions:
        versions = st.session_state.md_versions[filename]
        if len(versions) > 1:
            st.markdown("### 📚 Previous Versions")
            version_idx = st.selectbox(
                "Select version to view",
                range(len(versions)-1),
                format_func=lambda x: f"Version {len(versions)-1-x} - {versions[x]['timestamp']}"
            )
            
            if version_idx is not None:
                version = versions[version_idx]
                decoded_content = decode_content(version['content'])
                st.text_area(
                    "Content",
                    decoded_content,
                    height=200,
                    key=f"version_{filename}_{version_idx}",
                    disabled=True
                )
                if st.button(f"Restore to this version", key=f"restore_{filename}_{version_idx}"):
                    st.session_state.file_data[filename] = decoded_content
                    st.session_state.md_outline[filename] = parse_markdown_outline(decoded_content)
                    add_to_history(filename, decoded_content, "restored")
                    st.rerun()

# 🗺️ Map Maker - Creating a beautiful outline of our markdown
def parse_markdown_outline(content):
    """Generate an outline from markdown content"""
    lines = content.split('\n')
    outline = []
    for line in lines:
        if line.strip().startswith('#'):
            level = len(line.split()[0])
            title = line.strip('#').strip()
            outline.append({
                'level': level,
                'title': title,
                'indent': '    ' * (level - 1)
            })
    return outline

# 📑 Tab Master - Creating beautiful tabs for our markdown content
def create_markdown_tabs(content, filename):
    """Create tabs for markdown content viewing and editing"""
    tab1, tab2, tab3 = st.tabs(["📝 Editor", "👀 Preview", "🕒 History"])
    
    with tab1:
        edited_content = st.text_area(
            "Edit your markdown",
            content,
            height=300,
            key=f"edit_{filename}"
        )
        
        if edited_content != content:
            st.session_state.file_data[filename] = edited_content
            st.session_state.md_outline[filename] = parse_markdown_outline(edited_content)
            add_to_history(filename, edited_content, "edited")
            content = edited_content
    
    with tab2:
        st.markdown("### Preview")
        st.markdown(content)
        
        if filename in st.session_state.md_outline:
            st.markdown("---")
            st.markdown("### 📑 Document Outline")
            for item in st.session_state.md_outline[filename]:
                st.markdown(f"{item['indent']}• {item['title']}")
    
    with tab3:
        show_markdown_versions(filename)
    
    return content

# 📤 File Reader - Smart file reading with a smile!
def read_file_content(uploaded_file):
    """Smart file reader with enhanced markdown handling"""
    file_type = uploaded_file.name.split('.')[-1].lower()
    try:
        if file_type == 'md':
            content = uploaded_file.getvalue().decode()
            st.session_state.md_outline[uploaded_file.name] = parse_markdown_outline(content)
            st.session_state.rendered_content[uploaded_file.name] = content
            add_to_history(uploaded_file.name, content)
            return content, "md"
            
        elif file_type == 'csv':
            df = pd.read_csv(uploaded_file)
            return df.to_string(), "csv"
            
        elif file_type == 'xlsx':
            df = pd.read_excel(uploaded_file)
            return df.to_string(), "xlsx"
            
        elif file_type == 'json':
            content = json.load(uploaded_file)
            return json.dumps(content, indent=2), "json"
            
        elif file_type == 'yaml':
            content = yaml.safe_load(uploaded_file)
            return yaml.dump(content), "yaml"
            
        else:  # Default text handling
            return uploaded_file.getvalue().decode(), "txt"
            
    except Exception as e:
        st.error(f"🚨 Oops! Error reading {uploaded_file.name}: {str(e)}")
        return None, None

# 💾 File Saver - Keeping our files safe and sound
def save_file_content(content, filename, file_type):
    """Smart file saver with enhanced markdown handling"""
    try:
        if file_type == "md":
            with open(filename, 'w') as f:
                f.write(content)
                st.session_state.rendered_content[filename] = content
                add_to_history(filename, content, "saved")
                
        elif file_type in ["csv", "xlsx"]:
            df = pd.read_csv(StringIO(content)) if file_type == "csv" else pd.read_excel(StringIO(content))
            if file_type == "csv":
                df.to_csv(filename, index=False)
            else:
                df.to_excel(filename, index=False)
                
        elif file_type == "json":
            with open(filename, 'w') as f:
                json.dump(json.loads(content), f, indent=2)
                
        elif file_type == "yaml":
            with open(filename, 'w') as f:
                yaml.dump(yaml.safe_load(content), f)
                
        else:  # Default text handling
            with open(filename, 'w') as f:
                f.write(content)
                
        return True
    except Exception as e:
        st.error(f"🚨 Error saving {filename}: {str(e)}")
        return False

# 🎭 Main Show - Where the magic happens!
def main():
    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
    
    # Show markdown history in sidebar
    show_sidebar_history()
    
    # Add tabs for different upload methods
    upload_tab, book_tab = st.tabs(["📤 File Upload", "📖 Book View"])
    
    with upload_tab:
        col1, col2 = st.columns(2)
        
        with col1:
            single_uploaded_file = st.file_uploader(
                "📤 Upload single file", 
                type=list(FILE_TYPES.keys()),
                help="Supports: " + ", ".join([f"{v} (.{k})" for k, v in FILE_TYPES.items()]),
                key="single_uploader"
            )
        
        with col2:
            multiple_uploaded_files = st.file_uploader(
                "📚 Upload multiple files",
                type=list(FILE_TYPES.keys()),
                accept_multiple_files=True,
                help="Upload multiple files to view as a book",
                key="multiple_uploader"
            )
        
        # Process single file upload
        if single_uploaded_file:
            content, file_type = read_file_content(single_uploaded_file)
            if content is not None:
                st.session_state.file_data[single_uploaded_file.name] = content
                st.session_state.file_types[single_uploaded_file.name] = file_type
                st.success(f"🎉 Loaded {FILE_TYPES.get(file_type, '📄')} file: {single_uploaded_file.name}")
        
        # Process multiple file upload
        if multiple_uploaded_files:
            for uploaded_file in multiple_uploaded_files:
                content, file_type = read_file_content(uploaded_file)
                if content is not None:
                    st.session_state.file_data[uploaded_file.name] = content
                    st.session_state.file_types[uploaded_file.name] = file_type
            st.success(f"🎉 Loaded {len(multiple_uploaded_files)} files")
        
        # Show file history
        show_file_history()
        
        # Show individual files
        if st.session_state.file_data:
            st.subheader("📂 Your Files")
            for filename, content in st.session_state.file_data.items():
                file_type = st.session_state.file_types[filename]
                with st.expander(f"{FILE_TYPES.get(file_type, '📄')} {filename}"):
                    if file_type == "md":
                        content = create_markdown_tabs(content, filename)
                    else:
                        edited_content = st.text_area(
                            "Content",
                            content,
                            height=300,
                            key=f"edit_{filename}"
                        )
                        if edited_content != content:
                            st.session_state.file_data[filename] = edited_content
                            content = edited_content
                    
                    if st.button(f"💾 Save {filename}"):
                        if save_file_content(content, filename, file_type):
                            st.success(f"✨ Saved {filename} successfully!")
    
    with book_tab:
        show_book_view()

if __name__ == "__main__":
    main()