import gradio as gr
import requests
import json
import datetime
import re
from bs4 import BeautifulSoup
from typing import Optional, Dict, Any
from urllib.parse import quote, urljoin

class ShabbatCandleLightingAgent:
    """
    AI Agent for finding Shabbat candle lighting times worldwide using Chabad.org
    """
    
    def __init__(self):
        self.base_url = "https://www.chabad.org"
        self.candle_lighting_url = "https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm"
    
    def get_user_ip_location(self) -> Optional[Dict[str, Any]]:
        """
        Enhanced IP-based location detection using multiple high-quality services
        """
        try:
            # Enhanced list of location services with better accuracy
            services = [
                {
                    "url": "https://ipapi.co/json/",
                    "parser": "ipapi_co",
                    "accuracy": "high"
                },
                {
                    "url": "http://ip-api.com/json/?fields=status,message,country,countryCode,region,regionName,city,zip,lat,lon,timezone,isp,query",
                    "parser": "ip_api", 
                    "accuracy": "medium"
                },
                {
                    "url": "https://ipgeolocation.abstractapi.com/v1/?api_key=free",
                    "parser": "abstractapi",
                    "accuracy": "high"
                },
                {
                    "url": "https://freegeoip.app/json/",
                    "parser": "freegeoip",
                    "accuracy": "medium"
                },
                {
                    "url": "https://api.ipify.org?format=json",
                    "parser": "ipify_then_geocode",
                    "accuracy": "low"
                }
            ]
            
            best_result = None
            all_results = []
            
            for service in services:
                try:
                    headers = {
                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
                        'Accept': 'application/json',
                        'Accept-Language': 'en-US,en;q=0.9'
                    }
                    
                    response = requests.get(service["url"], headers=headers, timeout=8)
                    if response.status_code == 200:
                        data = response.json()
                        parsed_location = self._parse_ip_location_data(data, service["parser"])
                        
                        if parsed_location and parsed_location.get('city'):
                            parsed_location['accuracy_level'] = service["accuracy"]
                            parsed_location['source'] = service["parser"]
                            all_results.append(parsed_location)
                            print(f"✅ {service['parser']}: {parsed_location['city']}, {parsed_location.get('country', '')}")
                            
                            # Keep the best result (prefer high accuracy sources)
                            if not best_result or service["accuracy"] == "high":
                                best_result = parsed_location
                        
                except Exception as e:
                    print(f"❌ Service {service['parser']} failed: {e}")
                    continue
            
            # Return best result with confidence assessment
            if best_result:
                best_result['all_results'] = all_results
                best_result['confidence'] = self._assess_location_confidence(all_results)
                print(f"🎯 Best location: {best_result['city']}, {best_result.get('country', '')} (confidence: {best_result['confidence']})")
                return best_result
                
        except Exception as e:
            print(f"Location detection error: {e}")
        
        return None
    
    def _parse_ip_location_data(self, data: dict, parser_type: str) -> Optional[Dict[str, Any]]:
        """Parse location data from different IP geolocation APIs"""
        try:
            if parser_type == "ipapi_co":
                if data.get('city') and not data.get('error'):
                    return {
                        'city': data.get('city'),
                        'country': data.get('country_name'),
                        'region': data.get('region'),
                        'lat': data.get('latitude'),
                        'lng': data.get('longitude'),
                        'timezone': data.get('timezone'),
                        'isp': data.get('org')
                    }
            
            elif parser_type == "ip_api":
                if data.get('status') == 'success':
                    return {
                        'city': data.get('city'),
                        'country': data.get('country'),
                        'region': data.get('regionName'),
                        'lat': data.get('lat'),
                        'lng': data.get('lon'),
                        'timezone': data.get('timezone'),
                        'isp': data.get('isp')
                    }
            
            elif parser_type == "abstractapi":
                if data.get('city') and not data.get('error'):
                    return {
                        'city': data.get('city'),
                        'country': data.get('country'),
                        'region': data.get('region'),
                        'lat': data.get('latitude'),
                        'lng': data.get('longitude'),
                        'timezone': data.get('timezone', {}).get('name') if isinstance(data.get('timezone'), dict) else data.get('timezone'),
                        'isp': data.get('connection', {}).get('isp_name') if isinstance(data.get('connection'), dict) else None
                    }
            
            elif parser_type == "freegeoip":
                if data.get('city'):
                    return {
                        'city': data.get('city'),
                        'country': data.get('country_name'),
                        'region': data.get('region_name'),
                        'lat': data.get('latitude'),
                        'lng': data.get('longitude'),
                        'timezone': data.get('time_zone')
                    }
                    
        except Exception as e:
            print(f"Parse error for {parser_type}: {e}")
        
        return None
    
    def _assess_location_confidence(self, all_results: list) -> str:
        """Assess confidence level based on multiple results"""
        if len(all_results) == 0:
            return "none"
        elif len(all_results) == 1:
            return "low"
        
        # Check if multiple services agree on the city
        cities = [result.get('city', '').lower() for result in all_results if result.get('city')]
        unique_cities = set(cities)
        
        if len(unique_cities) == 1 and len(cities) >= 2:
            return "high"
        elif len(unique_cities) <= 2 and len(cities) >= 2:
            return "medium"
        else:
            return "low"
        """
        Search for a city on Chabad.org and get the specific URL for candle lighting times
        """
        try:
            # Clean and format city name
            city_clean = city_name.strip()
            search_query = quote(city_clean)
            
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
                'Accept-Language': 'en-US,en;q=0.5',
                'Accept-Encoding': 'gzip, deflate',
                'Connection': 'keep-alive',
                'Upgrade-Insecure-Requests': '1'
            }
            
            # Try different search approaches for Chabad.org
            search_strategies = [
                # Direct city page approach
                f"https://www.chabad.org/calendar/candlelighting_cdo/jewish/{search_query}.htm",
                # Search with city parameter
                f"https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm?city={search_query}",
                # Alternative format
                f"https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Candle-Lighting-Times-{search_query}.htm",
                # General search
                f"https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm"
            ]
            
            for url in search_strategies:
                try:
                    response = requests.get(url, headers=headers, timeout=15)
                    if response.status_code == 200:
                        # Check if the response contains candle lighting information
                        content_lower = response.text.lower()
                        if any(keyword in content_lower for keyword in ['candle lighting', 'light candles', 'shabbat', 'friday']):
                            return url
                except Exception as e:
                    print(f"Failed to fetch {url}: {e}")
                    continue
            
            # Try POST request to the main search page
            try:
                post_data = {
                    'city': city_clean,
                    'submit': 'Get Times'
                }
                response = requests.post(self.candle_lighting_url, data=post_data, headers=headers, timeout=15)
                if response.status_code == 200 and 'candle lighting' in response.text.lower():
                    return response.url
            except Exception as e:
                print(f"POST request failed: {e}")
                
        except Exception as e:
            print(f"City search error: {e}")
        
        return self.candle_lighting_url  # Return main page as fallback
    
    def extract_candle_lighting_times(self, html_content: str, city_name: str) -> Dict[str, Any]:
        """
        Extract candle lighting times from Chabad.org HTML content using multiple strategies
        """
        try:
            soup = BeautifulSoup(html_content, 'html.parser')
            text = soup.get_text().lower()
            
            # Multiple patterns to find candle lighting times
            candle_patterns = [
                r'candle\s+lighting[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
                r'light\s+candles[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
                r'friday[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*candle)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*light)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*friday)'
            ]
            
            # Patterns for Havdalah times
            havdalah_patterns = [
                r'havdalah[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
                r'saturday[:\s]*(\d{1,2}:\d{2}(?:\s*[ap]m)?)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*havdalah)',
                r'(\d{1,2}:\d{2}\s*[ap]m?)(?=.*saturday)'
            ]
            
            # Find candle lighting time
            candle_time = None
            for pattern in candle_patterns:
                match = re.search(pattern, text, re.IGNORECASE)
                if match:
                    candle_time = match.group(1)
                    break
            
            # Find Havdalah time
            havdalah_time = None
            for pattern in havdalah_patterns:
                match = re.search(pattern, text, re.IGNORECASE)
                if match:
                    havdalah_time = match.group(1)
                    break
            
            # Look for times in common HTML elements
            if not candle_time or not havdalah_time:
                # Check for time elements with specific classes or IDs
                time_selectors = [
                    '[class*="time"]',
                    '[class*="candle"]',
                    '[class*="light"]',
                    '[id*="time"]',
                    '[id*="candle"]',
                    'td', 'span', 'div'
                ]
                
                for selector in time_selectors:
                    elements = soup.select(selector)
                    for element in elements:
                        element_text = element.get_text().strip()
                        time_match = re.search(r'\d{1,2}:\d{2}(?:\s*[ap]m)?', element_text, re.IGNORECASE)
                        if time_match:
                            time_found = time_match.group()
                            if not candle_time and any(word in element_text.lower() for word in ['candle', 'light', 'friday']):
                                candle_time = time_found
                            elif not havdalah_time and any(word in element_text.lower() for word in ['havdalah', 'saturday']):
                                havdalah_time = time_found
            
            # Calculate current Shabbat dates
            now = datetime.datetime.now()
            days_until_friday = (4 - now.weekday()) % 7
            if days_until_friday == 0 and now.hour >= 18:  # If it's Friday evening, get next Friday
                days_until_friday = 7
            
            friday = now + datetime.timedelta(days=days_until_friday)
            saturday = friday + datetime.timedelta(days=1)
            
            return {
                'city': city_name,
                'candle_lighting_time': candle_time,
                'havdalah_time': havdalah_time,
                'friday_date': friday.strftime('%B %d, %Y'),
                'saturday_date': saturday.strftime('%B %d, %Y'),
                'found_data': bool(candle_time or havdalah_time),
                'search_successful': True
            }
            
        except Exception as e:
            print(f"Time extraction error: {e}")
            return {
                'city': city_name,
                'candle_lighting_time': None,
                'havdalah_time': None,
                'friday_date': None,
                'saturday_date': None,
                'found_data': False,
                'search_successful': False,
                'error': str(e)
            }
    
    def get_backup_times(self, city_name: str) -> Optional[Dict[str, Any]]:
        """
        Try alternative sources for Shabbat times when Chabad.org fails
        """
        try:
            # Alternative Jewish calendar websites
            backup_urls = [
                f"https://www.hebcal.com/shabbat?city={quote(city_name)}",
                f"https://www.myzmanim.com/search.aspx?city={quote(city_name)}"
            ]
            
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
            }
            
            for url in backup_urls:
                try:
                    response = requests.get(url, headers=headers, timeout=10)
                    if response.status_code == 200:
                        times = self.extract_candle_lighting_times(response.text, city_name)
                        if times.get('found_data'):
                            times['source'] = 'backup'
                            return times
                except Exception as e:
                    print(f"Backup source {url} failed: {e}")
                    continue
                    
        except Exception as e:
            print(f"Backup sources error: {e}")
        
        return None
    
    def get_shabbat_times(self, city_input: str = "", auto_detect: bool = False) -> str:
        """
        Main function to get Shabbat candle lighting times
        """
        try:
            city_name = city_input.strip()
            location_info = ""
            
            # Auto-detect location using enhanced IP geolocation if requested
            if auto_detect and not city_name:
                print("🔍 Attempting to detect your location using IP geolocation...")
                location = self.get_user_ip_location()
                if location and location.get('city'):
                    city_name = location['city']
                    if location.get('country') and location['country'] not in city_name:
                        city_name += f", {location['country']}"
                    
                    # Add location detection info
                    confidence = location.get('confidence', 'unknown')
                    source = location.get('source', 'unknown')
                    
                    if confidence == 'high':
                        status_icon = "✅"
                        status_text = "High confidence"
                    elif confidence == 'medium':
                        status_icon = "⚠️"
                        status_text = "Medium confidence - please verify"
                    else:
                        status_icon = "🔍"
                        status_text = "Low confidence - may be inaccurate"
                    
                    location_info = f"""
**🌐 IP-Based Location Detection:**
{status_icon} **Detected:** {city_name}  
**Confidence:** {status_text}  
**Source:** {source}  

{('⚠️ *Note: IP location shows your internet provider\'s location, not exact address. For most accurate results, enter your city manually.*' if confidence != 'high' else '✅ *Multiple services confirmed this location*')}

---
"""
            
            if not city_name:
                return self._format_error_response("❌ Please enter a city name or enable auto-detection to search for Shabbat times.")
            
            # Search Chabad.org for the city
            print(f"🔍 Searching for Shabbat times in: {city_name}")
            city_url = self.search_city_on_chabad(city_name)
            
            result_data = None
            source = "Chabad.org"
            
            if city_url:
                try:
                    headers = {
                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
                    }
                    response = requests.get(city_url, headers=headers, timeout=15)
                    
                    if response.status_code == 200:
                        result_data = self.extract_candle_lighting_times(response.text, city_name)
                        print(f"📊 Extraction result: {result_data}")
                        
                except Exception as e:
                    print(f"❌ Chabad.org fetch error: {e}")
            
            # Try backup sources if Chabad.org didn't work well
            if not result_data or not result_data.get('found_data'):
                print("🔄 Trying backup sources...")
                backup_data = self.get_backup_times(city_name)
                if backup_data and backup_data.get('found_data'):
                    result_data = backup_data
                    source = "Alternative Jewish calendar source"
            
            # Format and return the response
            if result_data and result_data.get('found_data'):
                response = self._format_success_response(result_data, source, city_url)
                return location_info + response
            else:
                response = self._format_not_found_response(city_name, city_url)
                return location_info + response
                
        except Exception as e:
            print(f"Main function error: {e}")
            return self._format_error_response(f"❌ An error occurred: {str(e)}")
    
    def _format_geolocation_instructions(self) -> str:
        """Instructions for using browser geolocation"""
        return f"""
# 🕯️ Shabbat Candle Lighting Times

## 📍 Automatic Location Detection

To automatically detect your location, we need access to your device's GPS. Please follow these steps:

### 🔒 **Step 1: Enable Location Access**
1. Click the **"🌐 Get My Location"** button below
2. Your browser will ask for permission to access your location
3. Click **"Allow"** in the permission popup
4. Wait for your coordinates to be detected

### 📱 **Step 2: Location will be converted to city**
Once we get your GPS coordinates, we'll:
- Convert them to the nearest city name
- Automatically search for Shabbat times
- Display the results for your location

### ⚠️ **Privacy Note:**
- Your location is only used to find the nearest city
- No location data is stored or shared
- You can deny permission and enter your city manually instead

### 🌐 **Location Requirements:**
- **HTTPS connection** (secure website)
- **GPS-enabled device** (phone, tablet, or laptop with location services)
- **Browser permission** for location access

---

**Manual Alternative:** Enter your city name in the field above if you prefer not to share your location.

**Date:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
"""
    
    def _format_success_response(self, data: Dict[str, Any], source: str, url: str = None) -> str:
        """Format successful response with Shabbat times"""
        candle_time = data.get('candle_lighting_time', 'Not found')
        havdalah_time = data.get('havdalah_time', 'Not found')
        
        response = f"""
# 🕯️ Shabbat Candle Lighting Times

## 📍 Location: {data.get('city', 'Unknown')}

### 🕯️ **Candle Lighting (Friday)**
**Time:** {candle_time}  
**Date:** {data.get('friday_date', 'This Friday')}

### ⭐ **Havdalah (Saturday)**
**Time:** {havdalah_time}  
**Date:** {data.get('saturday_date', 'This Saturday')}

---

## 📋 **Important Notes:**
- 🕯️ Light Shabbat candles **18 minutes before sunset** on Friday
- ⭐ Havdalah is performed after **3 stars appear** on Saturday night  
- 🌍 Times are specific to your geographic location
- ⏰ Always verify times with your local rabbi or Jewish community

## 📚 **Source Information:**
**Data from:** {source}  
**Retrieved:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}  
{f"**URL:** {url}" if url else ""}

---

## 🙏 **Shabbat Shalom!**
*May your Shabbat be filled with peace, joy, and spiritual connection.*

**🔔 Reminder:** Set an alarm 30 minutes before candle lighting time to prepare properly.
"""
        return response
    
    def _format_not_found_response(self, city_name: str, url: str = None) -> str:
        """Format response when times are not found"""
        return f"""
# 🕯️ Shabbat Candle Lighting Times

## ❌ Times Not Found for {city_name}

We searched multiple sources but couldn't find specific Shabbat candle lighting times for **{city_name}**.

### 🔍 **What you can try:**
1. **Check spelling** - Make sure the city name is spelled correctly
2. **Add country** - Try "City, Country" format (e.g., "Paris, France")  
3. **Use major city** - Try the nearest major city instead
4. **Alternative spellings** - Try different variations of the city name

### 📍 **General Guidelines for {city_name}:**
- 🕯️ **Candle lighting:** Typically 18 minutes before sunset on Friday
- ⭐ **Havdalah:** Approximately 25-42 minutes after sunset on Saturday  
- 🌍 **Location matters:** Times vary significantly by geographic location

### 🌐 **Manual Resources:**
- 📱 **Chabad.org:** [Direct search]({url or 'https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm'})
- 📱 **Hebcal.com:** Alternative Jewish calendar
- 📞 **Local contacts:** Your synagogue or Chabad house

### 📞 **Local Resources:**
- Contact your local Chabad house or synagogue  
- Check with your Jewish community center
- Consult your rabbi for precise local customs

---

**Retrieved:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
"""
    
    def _format_error_response(self, error_message: str) -> str:
        """Format error response"""
        return f"""
# 🕯️ Shabbat Candle Lighting Times

## ⚠️ Error

{error_message}

### 🔄 **Please try:**
1. **Refresh** and try again
2. **Check internet connection**  
3. **Use a different city name**
4. **Visit Chabad.org directly:** [Candle Lighting Times](https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm)

### 📞 **Alternative:**
Contact your local synagogue or Chabad house for accurate times.

---

**Time:** {datetime.datetime.now().strftime('%B %d, %Y at %I:%M %p')}
"""

def create_shabbat_interface():
    """Create the Gradio interface for the Shabbat Candle Lighting Agent"""
    
    agent = ShabbatCandleLightingAgent()
    
    with gr.Blocks(title="🕯️ Shabbat Candle Lighting Times", theme=gr.themes.Soft()) as app:
        
        gr.Markdown("""
        # 🕯️ Shabbat Candle Lighting Times AI Agent
        
        **Get accurate Shabbat candle lighting and Havdalah times for any city worldwide**
        
        This AI agent searches Chabad.org and other reliable Jewish sources to find precise ritual times for your location.
        
        ---
        """)
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### 📍 Location Input")
                
                city_input = gr.Textbox(
                    label="🏙️ City Name",
                    placeholder="Enter city name (e.g., 'New York', 'London, UK', 'Tel Aviv, Israel')",
                    info="Enter manually or use automatic location detection below",
                    lines=1
                )
                
                # Add IP-based geolocation detection
                with gr.Row():
                    detect_ip_btn = gr.Button(
                        "🌐 Auto-Detect (IP Location)",
                        variant="secondary",
                        size="sm"
                    )
                    search_btn = gr.Button(
                        "🔍 Get Shabbat Times",
                        variant="primary",
                        size="sm"
                    )
                
                gr.Markdown("""
                ### 💡 **How to Use:**
                
                **🅰️ Manual Entry** (Most Accurate)
                - Enter your city name above and click "Get Shabbat Times"
                - Use format: "City, Country" for best results
                
                **🅱️ Auto-Detection** (Uses Your IP Location)
                - Click "Auto-Detect" to automatically find your approximate location
                - ⚠️ Note: IP location shows your internet provider's area, not exact address
                - May be off by 10-50 km from your actual location
                
                ### 🇮🇱 **Popular Israeli Cities:**
                Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod
                
                ### 🌍 **International Examples:**
                London, UK • Paris, France • New York, USA • Toronto, Canada
                """)
        
            with gr.Column(scale=2):
                output_area = gr.Markdown(
                    label="📋 Shabbat Times Results",
                    value="""
# 🕯️ Welcome!

### 🎯 **Two Ways to Find Shabbat Times:**

**🅰️ Manual Entry** (Most Reliable)
👆 Enter your city name above and click "Get Shabbat Times"

**🅱️ Auto-Detection** (Uses IP Geolocation)
👆 Click "Auto-Detect" to find your approximate location via internet provider

### 🇮🇱 **Common Israeli Cities:**
Use: Jerusalem, Tel Aviv, Haifa, Beer Sheva, Netanya, Ashdod

### 🌍 **International Cities:**  
Format: London, UK • Paris, France • New York, USA

---

**🕯️ Every Friday evening, Jewish families around the world light candles to welcome Shabbat**

**⚠️ Note:** Auto-detection uses IP location (approximate) - for best accuracy, enter city manually
                    """
                )
        
        # Example buttons for popular cities
        gr.Markdown("### 🌍 Quick Search - Popular Cities:")
        
        with gr.Row():
            # Israeli cities first for the detected user
            popular_cities = [
                "Jerusalem, Israel",
                "Tel Aviv, Israel", 
                "Haifa, Israel",
                "Beer Sheva, Israel",
                "Netanya, Israel",
                "Ashdod, Israel",
                # International cities
                "New York, NY",
                "London, UK",
                "Paris, France",
                "Toronto, Canada",
                "Los Angeles, CA",
                "Miami, FL"
            ]
            
            example_btns = []
            for i in range(0, len(popular_cities), 4):
                with gr.Row():
                    for city in popular_cities[i:i+4]:
                        btn = gr.Button(f"📍 {city}", size="sm")
                        example_btns.append((btn, city))
        
        # Button click handlers 
        search_btn.click(
            fn=agent.get_shabbat_times,
            inputs=[city_input, gr.State(False)],  # auto_detect = False for manual search
            outputs=output_area
        )
        
        # IP-based auto-detection
        detect_ip_btn.click(
            fn=agent.get_shabbat_times,
            inputs=[gr.State(""), gr.State(True)],  # empty city, auto_detect = True
            outputs=output_area
        )
        
        # Example button handlers
        for btn, city in example_btns:
            btn.click(
                fn=lambda c=city: agent.get_shabbat_times(c, False),
                outputs=output_area
            )
        
        # Resources and information
        with gr.Accordion("📚 Resources & Information", open=False):
            gr.Markdown("""
            ### 🕯️ **About Shabbat Candle Lighting:**
            
            **Candle Lighting Time:**
            - Performed on Friday evening before sunset
            - Typically 18 minutes before sunset (varies by community)  
            - Marks the beginning of Shabbat
            - Usually done by the woman of the house
            
            **Havdalah Time:**
            - Performed on Saturday evening after sunset
            - When three medium-sized stars are visible in the sky
            - Marks the end of Shabbat
            - Includes blessings over wine, spices, and candle
            
            ### 🌐 **Data Sources:**
            - **Primary:** [Chabad.org](https://www.chabad.org/calendar/candlelighting_cdo/aid/6226/jewish/Accurate-Shabbat-Candle-Lighting-Times.htm)
            - **Backup:** Hebcal.com and other Jewish calendar sites
            - **Method:** Intelligent web scraping with multiple fallback strategies
            
            ### ⚠️ **Important Disclaimers:**
            - Always consult your local rabbi for specific customs
            - Times may vary based on local Jewish community practices  
            - This tool is for reference only - not a substitute for religious guidance
            - Some communities light candles at different intervals before sunset
            
            ### 🔧 **Technical Features:**
            - **Browser GPS Geolocation** - Uses your device's actual GPS hardware
            - **Reverse Geocoding** - Converts GPS coordinates to city names
            - **Multiple search strategies** for maximum success on Chabad.org
            - **Intelligent pattern matching** to extract candle lighting times
            - **Fallback to alternative sources** if needed
            - **Privacy-focused** - location data never stored or shared
            """)
        
        gr.Markdown("""
        ---
        
        **🙏 Shabbat Shalom!** | Built with ❤️ for the global Jewish community
        
        *For questions about Jewish law or local customs, please consult your rabbi or local Jewish community.*
        """)
    
    return app

# Main execution
if __name__ == "__main__":
    app = create_shabbat_interface()
    
    # Launch the application
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False,
        debug=False,
        show_error=True
    )