#!/usr/bin/env python3
"""
Analyze file content and generate descriptive name
Usage: python3 analyze-file.py <file_path>
"""

import sys
import os
import mimetypes
from pathlib import Path

def get_file_info(file_path):
    """Get basic file information"""
    stat = os.stat(file_path)
    return {
        "name": os.path.basename(file_path),
        "size": stat.st_size,
        "mime": mimetypes.guess_type(file_path)[0] or "application/octet-stream",
        "ext": Path(file_path).suffix.lower()
    }

def analyze_document(file_path):
    """Extract info from PDF/DOCX/TXT"""
    ext = Path(file_path).suffix.lower()
    
    if ext == '.pdf':
        return analyze_pdf(file_path)
    elif ext in ['.docx', '.doc']:
        return analyze_docx(file_path)
    elif ext == '.txt':
        return analyze_txt(file_path)
    else:
        return {"type": "document", "description": "Unknown document"}

def analyze_pdf(file_path):
    """Extract PDF metadata and first page text"""
    try:
        import PyPDF2
        with open(file_path, 'rb') as f:
            reader = PyPDF2.PdfReader(f)
            meta = reader.metadata
            
            # Get first page text (limited)
            text = ""
            if len(reader.pages) > 0:
                text = reader.pages[0].extract_text()[:500]
            
            return {
                "type": "pdf",
                "title": meta.get('/Title', ''),
                "author": meta.get('/Author', ''),
                "pages": len(reader.pages),
                "preview": text,
                "description": f"PDF: {meta.get('/Title', 'Untitled')} ({len(reader.pages)} pages)"
            }
    except:
        return {"type": "pdf", "description": "PDF document"}

def analyze_image(file_path):
    """Analyze image content using AI vision"""
    # Use AI to describe image
    prompt = "Describe this image in 5-7 words for a filename"
    
    # Implementation depends on your AI setup
    description = call_vision_model(file_path, prompt)
    
    return {
        "type": "image",
        "description": description,
        "dimensions": get_image_dimensions(file_path)
    }

def analyze_archive(file_path):
    """List contents of ZIP/tar files"""
    import zipfile
    import tarfile
    
    ext = Path(file_path).suffix.lower()
    
    try:
        if ext == '.zip':
            with zipfile.ZipFile(file_path, 'r') as zf:
                files = zf.namelist()[:10]  # First 10 files
                return {
                    "type": "zip",
                    "contents": files,
                    "file_count": len(zf.namelist()),
                    "description": f"ZIP archive with {len(zf.namelist())} files"
                }
        elif ext in ['.tar', '.gz', '.bz2']:
            with tarfile.open(file_path, 'r') as tf:
                files = tf.getnames()[:10]
                return {
                    "type": "archive",
                    "contents": files,
                    "description": f"Archive: {', '.join(files[:3])}..."
                }
    except:
        return {"type": "archive", "description": "Compressed archive"}

def generate_filename(file_path, analysis):
    """Generate descriptive filename using AI"""
    
    info = get_file_info(file_path)
    
    prompt = f"""Generate a concise, descriptive filename (2-4 words) for this file:

Original: {info['name']}
Type: {analysis.get('type', 'file')}
Description: {analysis.get('description', 'Unknown')}

Rules:
- Use snake_case (lowercase, underscores)
- Include date if relevant: YYYY-MM-DD
- Be specific but concise
- Max 50 characters

Output only the filename without extension."""

    # Call AI model
    new_name = call_ai_model(prompt)
    
    # Clean up
    new_name = new_name.strip().replace(' ', '_').lower()
    new_name = ''.join(c for c in new_name if c.isalnum() or c in '_-')
    
    # Add date prefix if not present
    if not new_name.startswith('20'):  # No year prefix
        from datetime import datetime
        date_prefix = datetime.now().strftime("%Y-%m-%d")
        new_name = f"{date_prefix}_{new_name}"
    
    return new_name + info['ext']

def determine_folder(file_path, analysis):
    """Determine destination folder based on file type and content"""
    
    info = get_file_info(file_path)
    mime = info['mime']
    
    # By MIME type
    if mime.startswith('image/'):
        if 'screenshot' in analysis.get('description', '').lower():
            return 'Images/Screenshots'
        elif 'design' in analysis.get('description', '').lower():
            return 'Images/Designs'
        return 'Images/Photos'
    
    elif mime.startswith('application/pdf'):
        desc = analysis.get('description', '').lower()
        if any(word in desc for word in ['invoice', 'bill', 'receipt', 'payment']):
            return 'Documents/Invoices'
        elif any(word in desc for word in ['manual', 'guide', 'documentation']):
            return 'Documents/Manuals'
        elif any(word in desc for word in ['report', 'analysis', 'data']):
            return 'Documents/Work'
        return 'Documents'
    
    elif mime.startswith('application/zip') or mime.startswith('application/x-'):
        return 'Archives'
    
    elif mime.startswith('video/'):
        return 'Media/Video'
    
    elif mime.startswith('audio/'):
        return 'Media/Audio'
    
    # By extension
    ext = info['ext']
    if ext in ['.exe', '.dmg', '.pkg', '.deb', '.rpm']:
        return 'Software'
    elif ext in ['.csv', '.json', '.xml', '.sql']:
        return 'Data'
    
    return 'Other'

def main():
    if len(sys.argv) < 2:
        print("Usage: python3 analyze-file.py <file_path>")
        sys.exit(1)
    
    file_path = sys.argv[1]
    
    print(f"🔍 Analyzing: {os.path.basename(file_path)}")
    
    # Analyze based on type
    info = get_file_info(file_path)
    
    if info['mime'].startswith('image/'):
        analysis = analyze_image(file_path)
    elif info['mime'].startswith('application/pdf'):
        analysis = analyze_document(file_path)
    elif info['ext'] in ['.zip', '.tar', '.gz']:
        analysis = analyze_archive(file_path)
    else:
        analysis = {"type": "file", "description": f"{info['ext']} file"}
    
    # Generate new name
    new_filename = generate_filename(file_path, analysis)
    folder = determine_folder(file_path, analysis)
    
    print(f"📁 Destination: {folder}/")
    print(f"📝 New name: {new_filename}")
    
    # Output for script processing
    result = {
        "original": info['name'],
        "new_name": new_filename,
        "folder": folder,
        "analysis": analysis
    }
    
    import json
    print(json.dumps(result))

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Archive files older than 30 days to Google Drive
Usage: python3 archive-old.py
"""

import os
import subprocess
from datetime import datetime, timedelta
from pathlib import Path

DOWNLOADS_DIR = os.path.expanduser("~/Downloads")
ARCHIVE_AGE_DAYS = 30
DRIVE_FOLDER_ID = "your-google-drive-folder-id"

def get_file_age(file_path):
    """Get file age in days"""
    stat = os.stat(file_path)
    mtime = datetime.fromtimestamp(stat.st_mtime)
    return (datetime.now() - mtime).days

def upload_to_drive(file_path, folder_id):
    """Upload file to Google Drive using gog CLI"""
    try:
        result = subprocess.run(
            ["gog", "drive", "upload", file_path, "--parent", folder_id],
            capture_output=True,
            text=True
        )
        return result.returncode == 0
    except:
        return False

def archive_file(file_path):
    """Archive single file"""
    rel_path = os.path.relpath(file_path, DOWNLOADS_DIR)
    print(f"📦 Archiving: {rel_path}")
    
    if upload_to_drive(file_path, DRIVE_FOLDER_ID):
        os.remove(file_path)
        print(f"✅ Archived and removed: {rel_path}")
        return True
    else:
        print(f"❌ Failed to archive: {rel_path}")
        return False

def main():
    print("🔍 Scanning for old files...")
    
    archived = 0
    failed = 0
    
    for root, dirs, files in os.walk(DOWNLOADS_DIR):
        # Skip hidden directories
        dirs[:] = [d for d in dirs if not d.startswith('.')]
        
        for file in files:
            file_path = os.path.join(root, file)
            
            # Skip system files
            if file.startswith('.') or file.endswith('.tmp'):
                continue
            
            age = get_file_age(file_path)
            if age > ARCHIVE_AGE_DAYS:
                if archive_file(file_path):
                    archived += 1
                else:
                    failed += 1
    
    print(f"\n📊 Summary: {archived} archived, {failed} failed")
    print(f"💾 Space saved: ~{archived * 5}MB (estimated)")

if __name__ == "__main__":
    main()

def find_duplicates(directory):
    """Find duplicate files by hash"""
    import hashlib
    
    hashes = {}
    for root, _, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            file_hash = hashlib.md5(open(file_path, 'rb').read()).hexdigest()
            
            if file_hash in hashes:
                print(f"Duplicate found: {file_path}")
                # Handle duplicate (delete, move, etc.)
            else:
                hashes[file_hash] = file_path

def search_by_content(query, directory):
    """Search files by AI-analyzed content"""
    # Build index of file descriptions
    # Search using embeddings or keywords
    pass