app.py

import gradio as gr
import asyncio
from search_engine import search, advanced_search
from osint_engine import create_report

def format_results(results):
    if not results:
        return "No results found."
        
    if isinstance(results, list):
        # Format web search results
        formatted_results = []
        for result in results:
            formatted_result = f"""
### [{result['title']}]({result['url']})

{result['summary']}

**Source:** {result['url']}
**Published:** {result.get('published_date', 'N/A')}
            """
            formatted_results.append(formatted_result)
        return "\n---\n".join(formatted_results)
    elif isinstance(results, dict):
        # Format OSINT results
        if "error" in results:
            return f"Error: {results['error']}"
            
        formatted = []
        
        # Web results
        if "web" in results:
            formatted.append(format_results(results["web"]))
        
        # Username/Platform results
        if "platforms" in results:
            platforms = results["platforms"]
            if platforms:
                formatted.append("\n### 🔍 Platform Results\n")
                for platform in platforms:
                    formatted.append(f"""
- **Platform:** {platform['platform']}
  **URL:** [{platform['url']}]({platform['url']})
  **Status:** {'Found ✅' if platform.get('exists', False) else 'Not Found ❌'}
""")
                    
        # Image analysis
        if "analysis" in results:
            analysis = results["analysis"]
            if analysis:
                formatted.append("\n### 🖼️ Image Analysis\n")
                for key, value in analysis.items():
                    formatted.append(f"- **{key.title()}:** {value}")
                    
        # Similar images
        if "similar_images" in results:
            similar = results["similar_images"]
            if similar:
                formatted.append("\n### 🔍 Similar Images\n")
                for img in similar:
                    formatted.append(f"- [{img['source']}]({img['url']})")
                    
        # Location info
        if "location" in results:
            location = results["location"]
            if location and not isinstance(location, str):
                formatted.append("\n### 📍 Location Information\n")
                for key, value in location.items():
                    if key != 'raw':
                        formatted.append(f"- **{key.title()}:** {value}")
                        
        # Domain info
        if "domain" in results:
            domain = results["domain"]
            if domain and not isinstance(domain, str):
                formatted.append("\n### 🌐 Domain Information\n")
                for key, value in domain.items():
                    formatted.append(f"- **{key.title()}:** {value}")
                    
        # Historical data
        if "historical" in results:
            historical = results["historical"]
            if historical:
                formatted.append("\n### 📅 Historical Data\n")
                for entry in historical[:5]:  # Limit to 5 entries
                    formatted.append(f"""
- **Date:** {entry.get('timestamp', 'N/A')}
  **URL:** [{entry.get('url', 'N/A')}]({entry.get('url', '#')})
  **Type:** {entry.get('mime_type', 'N/A')}
""")
        
        return "\n".join(formatted) if formatted else "No relevant information found."
    else:
        return str(results)

def safe_search(query, search_type="web", max_results=5, platform=None, 
                image_url=None, phone=None, location=None, domain=None):
    """Safe wrapper for search functions"""
    try:
        kwargs = {
            "max_results": max_results,
            "platform": platform,
            "phone": phone,
            "location": location,
            "domain": domain
        }
        
        if search_type == "web":
            results = search(query, max_results)
        else:
            # For async searches
            if search_type == "image" and image_url:
                query = image_url
            loop = asyncio.new_event_loop()
            asyncio.set_event_loop(loop)
            results = loop.run_until_complete(advanced_search(query, search_type, **kwargs))
            loop.close()
            
        return format_results(results)
    except Exception as e:
        return f"Error: {str(e)}"

# Create Gradio interface
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🔍 Intelligent Search Engine")
    gr.Markdown("""
    An AI-powered search engine with advanced OSINT capabilities.
    
    Features:
    - Web search with AI summaries
    - Username search across platforms
    - Image search and analysis
    - Social media profile search
    - Personal information gathering
    - Historical data search
    """)
    
    with gr.Tab("Web Search"):
        with gr.Row():
            query_input = gr.Textbox(
                label="Search Query",
                placeholder="Enter your search query...",
                lines=2
            )
            max_results = gr.Slider(
                minimum=1,
                maximum=10,
                value=5,
                step=1,
                label="Number of Results"
            )
        search_button = gr.Button("Search")
        results_output = gr.Markdown(label="Search Results")
        search_button.click(
            fn=lambda q, n: safe_search(q, "web", n),
            inputs=[query_input, max_results],
            outputs=results_output
        )
        
    with gr.Tab("Username Search"):
        username_input = gr.Textbox(
            label="Username",
            placeholder="Enter username to search..."
        )
        username_button = gr.Button("Search Username")
        username_output = gr.Markdown(label="Username Search Results")
        username_button.click(
            fn=lambda u: safe_search(u, "username"),
            inputs=username_input,
            outputs=username_output
        )
        
    with gr.Tab("Image Search"):
        image_url = gr.Textbox(
            label="Image URL",
            placeholder="Enter image URL to search..."
        )
        image_button = gr.Button("Search Image")
        image_output = gr.Markdown(label="Image Search Results")
        image_button.click(
            fn=lambda u: safe_search(u, "image", image_url=u),
            inputs=image_url,
            outputs=image_output
        )
        
    with gr.Tab("Social Media Search"):
        with gr.Row():
            social_username = gr.Textbox(
                label="Username",
                placeholder="Enter username..."
            )
            platform = gr.Dropdown(
                choices=["all", "instagram", "twitter", "reddit"],
                value="all",
                label="Platform"
            )
        social_button = gr.Button("Search Social Media")
        social_output = gr.Markdown(label="Social Media Results")
        social_button.click(
            fn=lambda u, p: safe_search(u, "social", platform=p),
            inputs=[social_username, platform],
            outputs=social_output
        )
        
    with gr.Tab("Personal Info"):
        with gr.Row():
            phone = gr.Textbox(label="Phone Number", placeholder="+1234567890")
            location = gr.Textbox(label="Location", placeholder="City, Country")
            domain = gr.Textbox(label="Domain", placeholder="example.com")
        personal_button = gr.Button("Gather Information")
        personal_output = gr.Markdown(label="Personal Information Results")
        personal_button.click(
            fn=lambda p, l, d: safe_search("", "personal", phone=p, location=l, domain=d),
            inputs=[phone, location, domain],
            outputs=personal_output
        )
        
    with gr.Tab("Historical Data"):
        url_input = gr.Textbox(
            label="URL",
            placeholder="Enter URL to search historical data..."
        )
        historical_button = gr.Button("Search Historical Data")
        historical_output = gr.Markdown(label="Historical Data Results")
        historical_button.click(
            fn=lambda u: safe_search(u, "historical"),
            inputs=url_input,
            outputs=historical_output
        )
        
    gr.Markdown("""
    ### Examples
    Try these example searches:
    - Web Search: "Latest developments in artificial intelligence"
    - Username: "johndoe"
    - Image URL: "https://images.app.goo.gl/w5BtxZKvzg6BdkGE8"
    - Social Media: "techuser" on Twitter
    - Historical Data: "example.com"
    """)

# Launch the app
if __name__ == "__main__":
    demo.launch()