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

# File type definitions
FILE_TYPES = {
    "md": "📝 Markdown",
    "txt": "📄 Text",
    "json": "🔧 JSON",
    "csv": "📊 CSV",
    "xlsx": "📗 Excel",
    "yaml": "⚙️ YAML",
    "xml": "🔗 XML"
}

# Initialize session state
for key in ['file_data', 'file_types', 'md_outline', 'rendered_content', 
           'file_history', 'md_versions', 'md_files_history', 'combined_markdown']:
    if key not in st.session_state:
        st.session_state[key] = {} if key in ['file_data', 'file_types', 'md_outline', 
                                            'rendered_content', 'md_versions'] else [] if key in ['file_history', 
                                            'md_files_history'] else ""

def encode_content(content):
    """Encode content to base64"""
    return base64.b64encode(content.encode()).decode()

def decode_content(encoded_content):
    """Decode content from base64"""
    return base64.b64decode(encoded_content.encode()).decode()

def parse_markdown_outline(content):
    """Generate an outline from markdown content"""
    return [{'level': len(line.split()[0]), 'title': line.strip('#').strip(), 
             'indent': '    ' * (len(line.split()[0]) - 1)} 
            for line in content.split('\n') if line.strip().startswith('#')]

def get_binary_file_downloader_html(bin_file, file_label='File'):
    """Generate download link"""
    b64 = encode_content(bin_file)
    return f'<a href="data:text/plain;base64,{b64}" download="{file_label}">📥 Download {file_label}</a>'

def add_to_history(filename, content, action="uploaded"):
    """Add a file action to history with timestamp"""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    encoded_content = encode_content(content)
    
    st.session_state.file_history.insert(0, {
        "timestamp": timestamp,
        "filename": filename,
        "action": action,
        "content": encoded_content
    })
    
    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()

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

def scan_and_load_files():
    """Scan directory for supported files and load them"""
    loaded_files = []
    for ext in FILE_TYPES.keys():
        for filepath in glob.glob(f"*.{ext}"):
            try:
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()
                    file_type = filepath.split('.')[-1].lower()
                    
                    st.session_state.file_data[filepath] = content
                    st.session_state.file_types[filepath] = file_type
                    
                    if file_type == 'md':
                        st.session_state.md_outline[filepath] = parse_markdown_outline(content)
                        st.session_state.rendered_content[filepath] = content
                        if filepath not in [f["filename"] for f in st.session_state.md_files_history]:
                            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

def show_markdown_versions(filename):
    """Display previous versions of a markdown file"""
    if filename in st.session_state.md_versions and len(st.session_state.md_versions[filename]) > 1:
        st.markdown("### 📚 Previous Versions")
        version_idx = st.selectbox(
            "Select version to view",
            range(len(st.session_state.md_versions[filename])-1),
            format_func=lambda x: f"Version {len(st.session_state.md_versions[filename])-1-x} - {st.session_state.md_versions[filename][x]['timestamp']}"
        )
        
        if version_idx is not None:
            version = st.session_state.md_versions[filename][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()

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("---\n### 📑 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

def show_sidebar_history():
    """Display markdown file history in sidebar"""
    st.sidebar.markdown("### 📚 Markdown Files History")
    
    if st.sidebar.button("🗑️ Delete All (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"]
            for key in ['file_data', 'file_types', 'md_outline', 'rendered_content', 'md_versions']:
                if filename in st.session_state[key]:
                    del st.session_state[key][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 = ""
        st.sidebar.success(f"Deleted {len(files_to_remove)} 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("📂", 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:
            st.markdown(get_binary_file_downloader_html(
                decode_content(md_file['content']), md_file['filename']), unsafe_allow_html=True)

def show_file_history():
    """Display file history in 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']}")

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 in ['csv', 'xlsx']:
            df = pd.read_csv(uploaded_file) if file_type == 'csv' else pd.read_excel(uploaded_file)
            return df.to_string(), file_type
        elif file_type == 'json':
            return json.dumps(json.load(uploaded_file), indent=2), "json"
        elif file_type == 'yaml':
            return yaml.dump(yaml.safe_load(uploaded_file)), "yaml"
        else:
            return uploaded_file.getvalue().decode(), "txt"
    except Exception as e:
        st.error(f"🚨 Error reading {uploaded_file.name}: {str(e)}")
        return None, None

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))
            df.to_csv(filename, index=False) if file_type == "csv" 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:
            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

def main():
    # Perform initial file scan
    loaded_files = scan_and_load_files()
    
    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
    show_sidebar_history()
    
    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"
            )
        
        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}")
        
        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")
            st.rerun()
        
        show_file_history()
        
        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:
        if st.session_state.combined_markdown:
            st.markdown("## 📖 Book View")
            st.markdown(st.session_state.combined_markdown)

if __name__ == "__main__":
    main()