app.py

from flask import Flask, jsonify, render_template, request, redirect, url_for, flash, session
import requests
import pymysql
from pymysql import Error
import json
from datetime import datetime, timedelta
import threading
import time
import re
from threading import Lock
import random

app = Flask(__name__)
app.secret_key = 'flipkart-secret-key-2024'

# Database connection function
def get_db_connection():
    try:
        conn = pymysql.connect(
            host="localhost",
            user="root",
            password="root",
            database="disasters_db"
        )
        return conn
    except Exception as e:
        print(f"Database connection error: {e}")
        return None


NEWS_API_KEY = "b352d15e97cb4328aacf55eb74c3dd3e"  
WEATHER_API_KEY = "b020f18983b41a0d411e14d2c9850d68"  

DB_CONFIG = {
    'host': 'localhost',
    'user': 'root',      # Replace with your MySQL username
    'password': 'root',      # Replace with your MySQL password
    'database': 'disasters_db'  # Database name
}

db_lock = Lock()

MAX_EVENTS = 50

MAX_NEWS_AGE_DAYS = 4  

USE_MOCK_DATA = True

try:
    import spacy
    nlp = spacy.load("en_core_web_sm")
    USE_NER = True
    print("Using spaCy NER for location extraction")
except (ImportError, OSError):
    USE_NER = False
    print("spaCy not available, using regex for location extraction")
    print("To install spaCy: pip install spacy && python -m spacy download en_core_web_sm")

DISASTER_TYPES = {
    'earthquake': [
        'earthquake', 'seismic', 'tremor', 'quake', 'magnitude', 'richter',
        'tectonic', 'aftershock', 'epicenter', 'seismology', 'fault line',
        'ground shaking', 'seismic activity', 'geological', 'crustal movement'
    ],
    'flood': [
        'flood', 'flooding', 'deluge', 'inundation', 'overflow', 'waterlogged',
        'flash flood', 'river overflow', 'dam burst', 'levee breach', 'monsoon',
        'heavy rainfall', 'water surge', 'submersion', 'aquatic disaster'
    ],
    'hurricane': [
        'hurricane', 'cyclone', 'typhoon', 'storm', 'wind speed', 'landfall',
        'tropical storm', 'eye wall', 'storm surge', 'category', 'wind damage',
        'meteorological', 'atmospheric pressure', 'weather system', 'gale force'
    ],
    'wildfire': [
        'wildfire', 'forest fire', 'bushfire', 'blaze', 'burning', 'fire outbreak',
        'brush fire', 'grass fire', 'conflagration', 'fire spread', 'smoke',
        'evacuation fire', 'fire danger', 'combustion', 'fire suppression'
    ],
    'tornado': [
        'tornado', 'twister', 'funnel cloud', 'wind damage', 'vortex',
        'supercell', 'tornado alley', 'rotation', 'mesocyclone', 'downdraft',
        'debris field', 'tornado warning', 'severe weather', 'wind shear'
    ],
    'tsunami': [
        'tsunami', 'tidal wave', 'sea surge', 'ocean wave', 'seismic sea wave',
        'underwater earthquake', 'wave height', 'coastal flooding', 'marine disaster',
        'wave propagation', 'tsunami warning', 'wave impact', 'coastal evacuation'
    ],
    'volcanic': [
        'volcano', 'volcanic', 'eruption', 'lava', 'ash cloud', 'magma',
        'pyroclastic flow', 'volcanic ash', 'crater', 'molten rock', 'tephra',
        'volcanic activity', 'lava flow', 'volcanic explosion', 'geological hazard'
    ],
    'drought': [
        'drought', 'water shortage', 'dry spell', 'arid', 'water crisis',
        'precipitation deficit', 'water scarcity', 'agricultural drought',
        'meteorological drought', 'hydrological drought', 'desertification'
    ],
    'landslide': [
        'landslide', 'mudslide', 'rockslide', 'slope failure', 'debris flow',
        'mass wasting', 'soil erosion', 'geological hazard', 'slope instability',
        'rock fall', 'earth movement', 'terrain collapse', 'hillside collapse'
    ],
    'avalanche': [
        'avalanche', 'snow slide', 'snow avalanche', 'snow mass', 'alpine hazard',
        'snow pack', 'snow instability', 'mountain hazard', 'snow debris'
    ],
    'pandemic': [
        'pandemic', 'epidemic', 'outbreak', 'virus', 'disease spread', 'contagion',
        'infectious disease', 'public health emergency', 'viral outbreak',
        'health crisis', 'pathogen', 'transmission', 'quarantine', 'isolation'
    ],
    'terrorist': [
        'terrorist', 'bombing', 'attack', 'explosion', 'shooting', 'terrorism',
        'security threat', 'extremist', 'militant', 'insurgent', 'violence',
        'armed attack', 'security incident', 'threat assessment'
    ],
    'accident': [
        'accident', 'crash', 'collision', 'derailment', 'plane crash', 'incident',
        'transportation accident', 'industrial accident', 'vehicle accident',
        'train accident', 'maritime accident', 'aviation accident', 'mishap'
    ]
}

SEARCH_QUERIES = [
    # Earthquake queries
    'earthquake OR seismic activity OR tremor',
    'magnitude earthquake OR richter scale',
    'aftershock OR tectonic OR fault line',
    'ground shaking OR seismic event',
    'earthquake damage OR seismic disaster',
    
    # Flood queries
    'flood OR flooding OR flash flood',
    'river overflow OR dam burst OR levee breach',
    'heavy rainfall OR monsoon flooding',
    'water surge OR inundation OR deluge',
    'flood damage OR flood warning OR flood emergency',
    
    # Hurricane/Storm queries
    'hurricane OR tropical storm OR cyclone',
    'typhoon OR storm surge OR landfall',
    'category hurricane OR wind speed',
    'storm damage OR hurricane warning',
    'meteorological disaster OR severe weather',
    
    # Wildfire queries
    'wildfire OR forest fire OR bushfire',
    'fire outbreak OR blaze OR conflagration',
    'fire evacuation OR fire danger OR fire spread',
    'smoke OR fire suppression OR fire damage',
    'brush fire OR grass fire OR fire emergency',
    
    # Tornado queries
    'tornado OR twister OR funnel cloud',
    'tornado warning OR severe weather OR wind damage',
    'supercell OR mesocyclone OR tornado alley',
    'tornado outbreak OR tornado damage',
    'severe thunderstorm OR wind shear',
    
    # Tsunami queries
    'tsunami OR tidal wave OR seismic sea wave',
    'tsunami warning OR ocean wave OR sea surge',
    'coastal flooding OR marine disaster',
    'underwater earthquake OR wave impact',
    'tsunami evacuation OR wave height',
    
    # Volcanic queries
    'volcano OR volcanic eruption OR lava',
    'ash cloud OR pyroclastic flow OR magma',
    'volcanic ash OR volcanic activity',
    'lava flow OR volcanic explosion',
    'crater OR volcanic hazard OR tephra',
    
    # Other disaster queries
    'landslide OR mudslide OR rockslide',
    'drought OR water shortage OR water crisis',
    'avalanche OR snow slide OR alpine hazard',
    'pandemic OR epidemic OR disease outbreak',
    'terrorist attack OR bombing OR security threat',
    'accident OR crash OR collision OR derailment',
    'disaster OR emergency OR catastrophe OR crisis',
    'natural disaster OR man-made disaster',
    'emergency response OR disaster relief'
]

# Mock data for generating realistic disaster events
MOCK_DATA = {
    'earthquake': {
        'titles': [
            "Magnitude {magnitude} earthquake strikes {location}",
            "Strong earthquake hits {location}, buildings damaged",
            "Powerful {magnitude} quake shakes {location}",
            "{magnitude} earthquake reported near {location}",
            "Seismic activity: {magnitude} earthquake in {location}"
        ],
        'descriptions': [
            "A magnitude {magnitude} earthquake has struck {location}, causing {damage_level} damage to buildings and infrastructure. {casualty_info}",
            "Officials report a {magnitude} earthquake in {location}. {casualty_info} Emergency services are responding to the affected areas.",
            "A powerful earthquake measuring {magnitude} on the Richter scale has hit {location}. {damage_level} damage reported across the region. {casualty_info}",
            "Residents of {location} experienced strong shaking as a {magnitude} earthquake struck the area. {damage_level} damage has been reported. {casualty_info}",
            "Seismologists recorded a {magnitude} earthquake near {location}. {damage_level} damage to infrastructure reported. {casualty_info}"
        ],
        'magnitudes': ["4.5", "5.2", "5.8", "6.1", "6.7", "7.2", "7.9"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(5, 10000)),
            'damage_estimate': lambda: f"${random.randint(1, 500)} million"
        }
    },
    'flood': {
        'titles': [
            "Severe flooding affects {location} after heavy rainfall",
            "Flash floods force evacuations in {location}",
            "{location} underwater as rivers overflow",
            "Monsoon floods devastate communities in {location}",
            "Flood emergency declared in {location}"
        ],
        'descriptions': [
            "Heavy rainfall has caused severe flooding in {location}, with water levels rising to {water_level} meters. {casualty_info} Thousands have been evacuated.",
            "Flash floods have swept through {location}, causing {damage_level} damage to homes and businesses. {casualty_info}",
            "Rivers have overflowed in {location}, flooding residential areas and farmland. {casualty_info} Emergency services are conducting rescue operations.",
            "Continuous rainfall has led to widespread flooding across {location}. {damage_level} damage reported to infrastructure. {casualty_info}",
            "Authorities in {location} have declared a flood emergency as water levels continue to rise. {casualty_info} Evacuation centers have been established."
        ],
        'water_levels': ["1.5", "2", "3", "4", "5"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(100, 50000)),
            'damage_estimate': lambda: f"${random.randint(5, 800)} million"
        }
    },
    'hurricane': {
        'titles': [
            "Hurricane {name} makes landfall in {location}",
            "Category {category} hurricane {name} batters {location}",
            "{location} braces for Hurricane {name}",
            "Hurricane {name} causes widespread damage in {location}",
            "Tropical Storm {name} upgraded to hurricane as it approaches {location}"
        ],
        'descriptions': [
            "Hurricane {name}, a Category {category} storm with winds of {wind_speed} mph, has made landfall in {location}. {casualty_info}",
            "{location} is experiencing {damage_level} damage as Hurricane {name} moves through the region with sustained winds of {wind_speed} mph. {casualty_info}",
            "Authorities have ordered evacuations in {location} as Hurricane {name} approaches with wind speeds of {wind_speed} mph. {casualty_info}",
            "Hurricane {name} has caused widespread destruction in {location}. The Category {category} storm brought winds of {wind_speed} mph and heavy rainfall. {casualty_info}",
            "Residents of {location} are dealing with the aftermath of Hurricane {name}. The Category {category} storm caused {damage_level} damage across the region. {casualty_info}"
        ],
        'names': ["Maria", "Irma", "Harvey", "Dorian", "Florence", "Michael", "Laura", "Ida", "Katrina", "Sandy"],
        'categories': ["1", "2", "3", "4", "5"],
        'wind_speeds': ["75", "90", "110", "130", "155", "175"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(1000, 100000)),
            'damage_estimate': lambda: f"${random.randint(100, 5000)} million",
            'wind_speed': lambda: f"{random.randint(75, 175)} mph"
        }
    },
    'wildfire': {
        'titles': [
            "Massive wildfire spreads across {location}",
            "Forest fire forces evacuations in {location}",
            "Wildfire destroys homes in {location}",
            "Firefighters battle blaze in {location}",
            "Uncontained wildfire threatens communities in {location}"
        ],
        'descriptions': [
            "A fast-moving wildfire has spread across {location}, burning {acres} acres of land. {casualty_info} Evacuation orders have been issued for nearby communities.",
            "Firefighters are battling a large forest fire in {location} that has already consumed {acres} acres. {casualty_info}",
            "A wildfire in {location} has destroyed numerous homes and forced thousands to evacuate. The fire has burned {acres} acres and is {containment}% contained. {casualty_info}",
            "High winds are fueling a wildfire in {location} that has grown to {acres} acres. {casualty_info} Fire crews are working to establish containment lines.",
            "Authorities have declared a state of emergency in {location} as a wildfire continues to spread. The fire has burned {acres} acres and is {containment}% contained. {casualty_info}"
        ],
        'acres': ["500", "1,200", "5,000", "10,000", "25,000", "50,000", "100,000"],
        'containment': ["0", "5", "10", "25", "40", "60"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(100, 10000)),
            'damage_estimate': lambda: f"${random.randint(10, 1000)} million"
        }
    },
    'tornado': {
        'titles': [
            "Tornado tears through {location}",
            "Deadly tornado strikes {location}",
            "{location} devastated by powerful tornado",
            "Multiple tornadoes reported in {location}",
            "Tornado outbreak causes destruction in {location}"
        ],
        'descriptions': [
            "A {ef_rating} tornado has torn through {location}, causing {damage_level} damage to homes and businesses. {casualty_info}",
            "A powerful tornado struck {location} yesterday, leaving a path of destruction {path_width} miles wide. {casualty_info}",
            "Residents of {location} are assessing the damage after a {ef_rating} tornado hit the area. {casualty_info}",
            "Multiple tornadoes were reported in {location}, with one confirmed {ef_rating} tornado causing significant damage. {casualty_info}",
            "A tornado outbreak has caused widespread destruction across {location}. The strongest was rated {ef_rating}. {casualty_info}"
        ],
        'ef_ratings': ["EF-1", "EF-2", "EF-3", "EF-4", "EF-5"],
        'path_widths': ["0.5", "0.75", "1", "1.5", "2"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(10, 5000)),
            'damage_estimate': lambda: f"${random.randint(1, 200)} million"
        }
    },
    'tsunami': {
        'titles': [
            "Tsunami hits coastal areas of {location}",
            "Underwater earthquake triggers tsunami in {location}",
            "Tsunami warning issued for {location} after strong earthquake",
            "Coastal communities in {location} devastated by tsunami",
            "{location} on alert as tsunami approaches"
        ],
        'descriptions': [
            "A tsunami with waves up to {wave_height} meters high has struck coastal areas of {location}. {casualty_info}",
            "An underwater earthquake has triggered a tsunami that hit {location} with waves reaching {wave_height} meters. {casualty_info}",
            "Authorities have issued a tsunami warning for {location} after a strong offshore earthquake. Waves of up to {wave_height} meters are expected. {casualty_info}",
            "Coastal communities in {location} have been devastated by a tsunami with waves as high as {wave_height} meters. {casualty_info}",
            "A tsunami has caused {damage_level} damage along the coast of {location}. Wave heights of {wave_height} meters were recorded. {casualty_info}"
        ],
        'wave_heights': ["2", "3", "5", "8", "10", "15"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(100, 50000)),
            'damage_estimate': lambda: f"${random.randint(50, 2000)} million"
        }
    },
    'volcanic': {
        'titles': [
            "Volcano erupts in {location}",
            "{location} volcano shows increased activity",
            "Volcanic eruption forces evacuations in {location}",
            "Ash cloud from {location} volcano disrupts air travel",
            "Scientists monitor volcanic activity in {location}"
        ],
        'descriptions': [
            "The volcano in {location} has erupted, sending ash {ash_height} kilometers into the atmosphere. {casualty_info} Nearby communities have been evacuated.",
            "Increased volcanic activity has been reported at the {location} volcano. Authorities have raised the alert level to {alert_level}. {casualty_info}",
            "A volcanic eruption in {location} has forced thousands to evacuate. The volcano is spewing ash {ash_height} kilometers high. {casualty_info}",
            "An ash cloud from the {location} volcano has disrupted air travel in the region. The eruption sent ash {ash_height} kilometers into the sky. {casualty_info}",
            "Scientists are closely monitoring the {location} volcano after it showed signs of increased activity. The alert level has been raised to {alert_level}. {casualty_info}"
        ],
        'ash_heights': ["2", "5", "8", "10", "15", "20"],
        'alert_levels': ["Yellow", "Orange", "Red"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(100, 20000)),
            'damage_estimate': lambda: f"${random.randint(5, 500)} million"
        }
    },
    'drought': {
        'titles': [
            "Severe drought affects {location}",
            "Water shortage crisis worsens in {location}",
            "{location} declares emergency amid worst drought in decades",
            "Drought conditions intensify across {location}",
            "Agricultural sector in {location} devastated by prolonged drought"
        ],
        'descriptions': [
            "{location} is experiencing its worst drought in {years} years, with water reservoirs at {percentage}% capacity. {casualty_info}",
            "Authorities in {location} have implemented water restrictions as the drought enters its {months} month. {casualty_info}",
            "The agricultural sector in {location} has been severely affected by the ongoing drought, with crop losses estimated at {percentage}%. {casualty_info}",
            "Water shortages in {location} have reached critical levels as the drought continues. Reservoirs are at {percentage}% of normal levels. {casualty_info}",
            "Officials in {location} have declared a state of emergency due to the severe drought conditions that have persisted for {months} months. {casualty_info}"
        ],
        'years': ["10", "20", "30", "50", "100"],
        'months': ["3", "6", "9", "12", "18", "24"],
        'percentages': ["10", "20", "30", "40", "50"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(1000, 1000000)),
            'damage_estimate': lambda: f"${random.randint(10, 5000)} million"
        }
    },
    'landslide': {
        'titles': [
            "Landslide buries homes in {location}",
            "Heavy rains trigger deadly landslide in {location}",
            "Massive landslide blocks highway in {location}",
            "Mudslide destroys village in {location}",
            "Landslide risk high in {location} after continuous rainfall"
        ],
        'descriptions': [
            "A landslide has buried several homes in {location} following days of heavy rainfall. {casualty_info}",
            "Heavy rains have triggered a deadly landslide in {location}, causing {damage_level} damage to infrastructure. {casualty_info}",
            "A massive landslide has blocked a major highway in {location}, stranding hundreds of travelers. {casualty_info}",
            "A village in {location} has been partially destroyed by a mudslide that occurred after {rainfall} mm of rain fell in 24 hours. {casualty_info}",
            "Authorities in {location} have warned of high landslide risk after {rainfall} mm of continuous rainfall in the region. {casualty_info}"
        ],
        'rainfalls': ["100", "150", "200", "250", "300", "400"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(10, 1000)),
            'damage_estimate': lambda: f"${random.randint(1, 100)} million"
        }
    },
    'avalanche': {
        'titles': [
            "Avalanche strikes ski resort in {location}",
            "Massive snow avalanche reported in {location}",
            "Skiers caught in avalanche in {location}",
            "Avalanche warning issued for {location} mountains",
            "Search and rescue operations underway after {location} avalanche"
        ],
        'descriptions': [
            "An avalanche has struck a ski resort in {location}, burying several people under {snow_depth} meters of snow. {casualty_info}",
            "A massive snow avalanche has been reported in the mountains of {location}. Search and rescue teams have been deployed. {casualty_info}",
            "Several skiers were caught in an avalanche in {location}. The avalanche was triggered after heavy snowfall of {snow_depth} meters. {casualty_info}",
            "Authorities have issued an avalanche warning for the mountains in {location} following recent heavy snowfall. {casualty_info}",
            "Search and rescue operations are underway after an avalanche in {location} buried a group of mountaineers under {snow_depth} meters of snow. {casualty_info}"
        ],
        'snow_depths': ["1.5", "2", "3", "4", "5"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(2, 50)),
            'damage_estimate': lambda: f"${random.randint(1, 20)} million"
        }
    },
    'pandemic': {
        'titles': [
            "New outbreak of {disease} reported in {location}",
            "{location} implements measures to contain {disease} spread",
            "Health emergency declared in {location} amid {disease} outbreak",
            "{disease} cases surge in {location}",
            "{location} begins vaccination campaign against {disease}"
        ],
        'descriptions': [
            "Health officials in {location} have reported a new outbreak of {disease}, with {cases} cases confirmed so far. {casualty_info}",
            "Authorities in {location} have implemented strict measures to contain the spread of {disease} after {cases} new cases were reported. {casualty_info}",
            "A health emergency has been declared in {location} as {disease} cases reach {cases}. {casualty_info}",
            "{location} is experiencing a surge in {disease} cases, with {cases} new infections reported in the past 24 hours. {casualty_info}",
            "A vaccination campaign against {disease} has begun in {location} after the number of cases reached {cases}. {casualty_info}"
        ],
        'diseases': ["COVID-19", "Influenza", "Dengue fever", "Ebola", "Zika virus", "Cholera", "Measles"],
        'cases': ["50", "100", "500", "1,000", "5,000", "10,000", "50,000"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(50, 1000000)),
            'damage_estimate': lambda: f"${random.randint(1, 10000)} million"
        }
    },
    'terrorist': {
        'titles': [
            "Explosion reported in {location}",
            "Security incident under investigation in {location}",
            "Authorities respond to incident in {location}",
            "Emergency services deployed to {location} following incident",
            "Security alert in {location} after incident"
        ],
        'descriptions': [
            "An explosion has been reported in {location}. Emergency services are at the scene. {casualty_info}",
            "Security forces are investigating an incident in {location}. The area has been cordoned off. {casualty_info}",
            "Authorities have responded to a security incident in {location}. {casualty_info} The public is advised to avoid the area.",
            "Emergency services have been deployed to {location} following a security incident. {casualty_info}",
            "A security alert has been issued in {location} after an incident. {casualty_info} Investigations are ongoing."
        ],
        'additional_info': {
            'affected_people': lambda: str(random.randint(1, 500)),
            'damage_estimate': lambda: f"${random.randint(1, 100)} million"
        }
    },
    'accident': {
        'titles': [
            "Major traffic accident on highway near {location}",
            "Train derailment reported in {location}",
            "Plane crash near {location} airport",
            "Industrial accident at factory in {location}",
            "Multi-vehicle collision causes chaos on {location} roads"
        ],
        'descriptions': [
            "A major traffic accident involving {vehicles} vehicles has occurred on the highway near {location}. {casualty_info}",
            "A train has derailed in {location}, causing significant disruption to rail services. {casualty_info}",
            "A plane carrying {passengers} passengers has crashed near {location} airport. Emergency services are at the scene. {casualty_info}",
            "An industrial accident has occurred at a factory in {location}. {casualty_info} Authorities are investigating the cause.",
            "A multi-vehicle collision has caused chaos on roads in {location}. {casualty_info} Traffic diversions are in place."
        ],
        'vehicles': ["2", "3", "4", "5", "multiple"],
        'passengers': ["10", "50", "100", "150", "200"],
        'additional_info': {
            'affected_people': lambda: str(random.randint(1, 200)),
            'damage_estimate': lambda: f"${random.randint(1, 50)} million"
        }
    }
}

# Location data for mock generation
LOCATIONS = [
    # North America
    "Los Angeles, California", "New York City, New York", "Miami, Florida", "Chicago, Illinois", 
    "Houston, Texas", "Toronto, Canada", "Mexico City, Mexico", "Vancouver, Canada",
    "Seattle, Washington", "Denver, Colorado", "Phoenix, Arizona", "Atlanta, Georgia",
    
    # South America
    "Rio de Janeiro, Brazil", "Buenos Aires, Argentina", "Lima, Peru", "Santiago, Chile",
    "Bogotá, Colombia", "Caracas, Venezuela", "Quito, Ecuador", "La Paz, Bolivia",
    
    # Europe
    "London, United Kingdom", "Paris, France", "Berlin, Germany", "Rome, Italy",
    "Madrid, Spain", "Amsterdam, Netherlands", "Brussels, Belgium", "Vienna, Austria",
    "Athens, Greece", "Stockholm, Sweden", "Oslo, Norway", "Helsinki, Finland",
    "Warsaw, Poland", "Prague, Czech Republic", "Budapest, Hungary", "Istanbul, Turkey",
    
    # Asia
    "Tokyo, Japan", "Beijing, China", "Shanghai, China", "Seoul, South Korea",
    "Mumbai, India", "Delhi, India", "Bangkok, Thailand", "Manila, Philippines",
    "Jakarta, Indonesia", "Kuala Lumpur, Malaysia", "Singapore", "Hanoi, Vietnam",
    "Dhaka, Bangladesh", "Karachi, Pakistan", "Dubai, UAE", "Riyadh, Saudi Arabia",
    
    # Africa
    "Cairo, Egypt", "Lagos, Nigeria", "Nairobi, Kenya", "Cape Town, South Africa",
    "Johannesburg, South Africa", "Casablanca, Morocco", "Tunis, Tunisia", "Algiers, Algeria",
    "Addis Ababa, Ethiopia", "Dar es Salaam, Tanzania", "Accra, Ghana", "Dakar, Senegal",
    
    # Oceania
    "Sydney, Australia", "Melbourne, Australia", "Brisbane, Australia", "Perth, Australia",
    "Auckland, New Zealand", "Wellington, New Zealand", "Port Moresby, Papua New Guinea",
    "Suva, Fiji", "Honolulu, Hawaii"
]

NEWS_SOURCES = [
    "Associated Press", "Reuters", "BBC News", "CNN", "Al Jazeera", 
    "The Guardian", "The New York Times", "Washington Post", "Fox News",
    "CNBC", "Bloomberg", "AFP", "NPR", "CBS News", "NBC News", "ABC News"
]

def execute_db_query(query, params=None, fetch=False):
    """Execute database query with proper locking"""
    with db_lock:
        try:
            conn = pymysql.connect(**DB_CONFIG)
            cursor = conn.cursor()
            
            if params:
                cursor.execute(query, params)
            else:
                cursor.execute(query)
            
            if fetch:
                if fetch == 'all':
                    result = cursor.fetchall()
                else:
                    result = cursor.fetchone()
            else:
                result = True
                
            conn.commit()
            cursor.close()
            conn.close()
            return result
        except Error as e:
            print(f"Database error: {e}")
            return None

def get_event_count():
    """Get current number of events in database"""
    result = execute_db_query("SELECT COUNT(*) FROM disasters", fetch='one')
    return result[0] if result else 0

def cleanup_old_events():
    """Remove oldest events if we exceed MAX_EVENTS"""
    current_count = get_event_count()
    if current_count >= MAX_EVENTS:
        # Delete oldest events to make room for new ones
        events_to_delete = current_count - MAX_EVENTS + 5  # Delete 5 extra to avoid frequent cleanup
        execute_db_query("""
            DELETE FROM disasters 
            WHERE id IN (
                SELECT id FROM (
                    SELECT id FROM disasters 
                    ORDER BY timestamp ASC 
                    LIMIT %s
                ) as temp
            )
        """, (events_to_delete,))
        print(f"Cleaned up {events_to_delete} old events. Current count: {get_event_count()}")

def cleanup_old_news():
    """Remove news articles older than MAX_NEWS_AGE_DAYS"""
    cutoff_date = (datetime.now() - timedelta(days=MAX_NEWS_AGE_DAYS)).isoformat()
    
    # Delete events older than cutoff date
    execute_db_query("""
        DELETE FROM disasters 
        WHERE timestamp < %s
    """, (cutoff_date,))

    print(f"Removed news articles older than {MAX_NEWS_AGE_DAYS} days")

# Initialize database
def init_db():
    with db_lock:
        try:
            # First, try to connect to the database
            conn =pymysql.connect(
                host=DB_CONFIG['host'],
                user=DB_CONFIG['user'],
                password=DB_CONFIG['password']
            )
            cursor = conn.cursor()
            
            # Create database if it doesn't exist
            cursor.execute(f"CREATE DATABASE IF NOT EXISTS {DB_CONFIG['database']}")
            cursor.execute(f"USE {DB_CONFIG['database']}")
            
            # Check if table exists
            cursor.execute("SHOW TABLES LIKE 'disasters'")
            if not cursor.fetchone():
                # Create new table with all columns
                cursor.execute('''CREATE TABLE disasters
                             (id INT AUTO_INCREMENT PRIMARY KEY, 
                              title TEXT, 
                              description TEXT, 
                              location TEXT, 
                              country TEXT, 
                              severity TEXT, 
                              disaster_type TEXT,
                              source TEXT, 
                              timestamp TEXT, 
                              url TEXT, 
                              affected_people TEXT,
                              damage_estimate TEXT, 
                              additional_info TEXT)''')
                print("Created disasters table")
            else:
                # Table exists, check for missing columns
                # MySQL doesn't support easy column existence check like SQLite
                # We'll use a different approach by getting column info
                cursor.execute("SHOW COLUMNS FROM disasters")
                columns = [column[0] for column in cursor.fetchall()]
                
                # Check and add missing columns
                required_columns = ['country', 'disaster_type', 'url', 'affected_people', 
                                   'damage_estimate', 'additional_info']
                
                for col in required_columns:
                    if col not in columns:
                        cursor.execute(f"ALTER TABLE disasters ADD COLUMN {col} TEXT")
                        print(f"Added missing column: {col}")
            
            conn.commit()
            cursor.close()
            conn.close()
            print("Database initialized successfully")
            
        except Error as e:
            print(f"Error initializing database: {e}")
            raise

# Generate mock disaster data with recent dates only
def generate_mock_disaster():
    """Generate a realistic mock disaster event within the last MAX_NEWS_AGE_DAYS days"""
    # Select random disaster type
    disaster_type = random.choice(list(MOCK_DATA.keys()))
    disaster_data = MOCK_DATA[disaster_type]
    
    # Select random location
    location = random.choice(LOCATIONS)
    country = location.split(", ")[-1] if ", " in location else location
    
    # Generate severity
    severity_options = ["Low", "Medium", "High"]
    severity_weights = [0.5, 0.3, 0.2]  # 50% Low, 30% Medium, 20% High
    severity = random.choices(severity_options, weights=severity_weights)[0]
    
    # Generate damage level based on severity
    damage_levels = {
        "Low": ["minor", "limited", "minimal", "slight"],
        "Medium": ["moderate", "significant", "considerable", "substantial"],
        "High": ["severe", "extensive", "major", "catastrophic", "devastating"]
    }
    damage_level = random.choice(damage_levels[severity])
    
    # Generate casualty info based on severity
    casualty_info = ""
    if severity == "Low":
        if random.random() < 0.7:  # 70% chance of no casualties for low severity
            casualty_info = "No casualties have been reported."
        else:
            casualty_info = f"{random.randint(1, 5)} minor injuries have been reported."
    elif severity == "Medium":
        if random.random() < 0.5:  # 50% chance of injuries only
            casualty_info = f"{random.randint(5, 50)} people have been injured."
        else:
            casualty_info = f"{random.randint(1, 10)} people have died and {random.randint(10, 100)} have been injured."
    else:  # High severity
        casualty_info = f"{random.randint(10, 1000)} people have died and {random.randint(50, 5000)} have been injured."
    
    # Generate title and description with placeholders replaced
    title_template = random.choice(disaster_data['titles'])
    description_template = random.choice(disaster_data['descriptions'])
    
    # Replace placeholders in templates
    replacements = {
        '{location}': location,
        '{damage_level}': damage_level,
        '{casualty_info}': casualty_info
    }
    
    # Add disaster-specific replacements
    if disaster_type == 'earthquake':
        replacements['{magnitude}'] = random.choice(disaster_data['magnitudes'])
    elif disaster_type == 'flood':
        replacements['{water_level}'] = random.choice(disaster_data['water_levels'])
    elif disaster_type == 'hurricane':
        replacements['{name}'] = random.choice(disaster_data['names'])
        replacements['{category}'] = random.choice(disaster_data['categories'])
        replacements['{wind_speed}'] = random.choice(disaster_data['wind_speeds'])
    elif disaster_type == 'wildfire':
        replacements['{acres}'] = random.choice(disaster_data['acres'])
        replacements['{containment}'] = random.choice(disaster_data['containment'])
    elif disaster_type == 'tornado':
        replacements['{ef_rating}'] = random.choice(disaster_data['ef_ratings'])
        replacements['{path_width}'] = random.choice(disaster_data['path_widths'])
    elif disaster_type == 'tsunami':
        replacements['{wave_height}'] = random.choice(disaster_data['wave_heights'])
    elif disaster_type == 'volcanic':
        replacements['{ash_height}'] = random.choice(disaster_data['ash_heights'])
        replacements['{alert_level}'] = random.choice(disaster_data['alert_levels'])
    elif disaster_type == 'drought':
        replacements['{years}'] = random.choice(disaster_data['years'])
        replacements['{months}'] = random.choice(disaster_data['months'])
        replacements['{percentage}'] = random.choice(disaster_data['percentages'])
    elif disaster_type == 'landslide':
        replacements['{rainfall}'] = random.choice(disaster_data['rainfalls'])
    elif disaster_type == 'avalanche':
        replacements['{snow_depth}'] = random.choice(disaster_data['snow_depths'])
    elif disaster_type == 'pandemic':
        replacements['{disease}'] = random.choice(disaster_data['diseases'])
        replacements['{cases}'] = random.choice(disaster_data['cases'])
    elif disaster_type == 'accident':
        replacements['{vehicles}'] = random.choice(disaster_data['vehicles'])
        replacements['{passengers}'] = random.choice(disaster_data['passengers'])
    
    # Replace all placeholders
    for placeholder, value in replacements.items():
        title_template = title_template.replace(placeholder, value)
        description_template = description_template.replace(placeholder, value)
    
    title = title_template
    description = description_template
    
    # Generate additional info
    additional_info = {}
    if 'additional_info' in disaster_data:
        for key, func in disaster_data['additional_info'].items():
            additional_info[key] = func()
    
    # Generate random timestamp within the last MAX_NEWS_AGE_DAYS days
    days_ago = random.randint(0, MAX_NEWS_AGE_DAYS - 1)  # Only within MAX_NEWS_AGE_DAYS
    hours_ago = random.randint(0, 23)
    minutes_ago = random.randint(0, 59)
    timestamp = (datetime.now() - timedelta(days=days_ago, hours=hours_ago, minutes=minutes_ago)).isoformat()
    
    # Generate random source
    source = random.choice(NEWS_SOURCES)
    
    return {
        'title': title,
        'description': description,
        'location': location,
        'country': country,
        'severity': severity,
        'disaster_type': disaster_type.title(),
        'source': source,
        'timestamp': timestamp,
        'url': f"https://example.com/news/{int(time.time())}-{disaster_type.replace(' ', '-')}",
        'affected_people': additional_info.get('affected_people', ''),
        'damage_estimate': additional_info.get('damage_estimate', ''),
        'additional_info': json.dumps(additional_info)
    }

# Generate and add mock disasters to database
def add_mock_disasters(count=10):
    """Generate and add mock disasters to the database"""
    # Check if we've reached the limit
    current_count = get_event_count()
    if current_count >= MAX_EVENTS:
        print(f"Event limit reached ({current_count}/{MAX_EVENTS}). Not adding more mock data.")
        return 0
    
    # Calculate how many we can add
    count = min(count, MAX_EVENTS - current_count)
    
    added = 0
    for _ in range(count):
        mock_disaster = generate_mock_disaster()
        
        # Insert into database - Note the %s placeholders for MySQL
        success = execute_db_query('''INSERT INTO disasters 
                    (title, description, location, country, severity, disaster_type,
                     source, timestamp, url, affected_people, damage_estimate, additional_info)
                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)''',
                 (mock_disaster['title'], mock_disaster['description'], 
                  mock_disaster['location'], mock_disaster['country'], 
                  mock_disaster['severity'], mock_disaster['disaster_type'],
                  mock_disaster['source'], mock_disaster['timestamp'],
                  mock_disaster['url'], mock_disaster['affected_people'],
                  mock_disaster['damage_estimate'], mock_disaster['additional_info']))
        
        if success is not None:
            added += 1
    
    print(f"Added {added} mock disasters to the database. Total: {get_event_count()}/{MAX_EVENTS}")
    return added

# Enhanced location extraction using NER
def extract_location_ner(text):
    """Extract locations using spaCy Named Entity Recognition"""
    try:
        doc = nlp(text)
        locations = []
        countries = []
        
        for ent in doc.ents:
            if ent.label_ in ["GPE", "LOC"]:  # Geopolitical entities and locations
                location_text = ent.text.strip()
                if len(location_text) > 2 and location_text not in locations:
                    # Check if it's likely a country
                    if ent.label_ == "GPE" and any(country.lower() in location_text.lower() 
                                                 for country in get_country_list()):
                        countries.append(location_text)
                    else:
                        locations.append(location_text)
        
        # Combine locations and return
        all_locations = locations + countries
        return ', '.join(all_locations[:3]) if all_locations else 'Unknown'
    except Exception as e:
        print(f"NER extraction error: {e}")
        return extract_location_regex(text)

# Fallback regex-based location extraction
def extract_location_regex(text):
    """Fallback location extraction using regex patterns"""
    location_patterns = [
        r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*),\s*([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b',
        r'\bin\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b',
        r'\bat\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b',
        r'\bnear\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b'
    ]
    
    locations = []
    for pattern in location_patterns:
        matches = re.findall(pattern, text)
        for match in matches:
            if isinstance(match, tuple):
                locations.extend([m for m in match if len(m) > 2])
            else:
                if len(match) > 2:
                    locations.append(match)
    
    non_locations = {'The', 'This', 'That', 'With', 'From', 'After', 'Before', 'During', 'Since'}
    locations = [loc for loc in locations if loc not in non_locations]
    
    return ', '.join(list(set(locations))[:3]) if locations else 'Unknown'

# Main location extraction function
def extract_location(text):
    """Extract location using NER if available, otherwise use regex"""
    if USE_NER:
        return extract_location_ner(text)
    else:
        return extract_location_regex(text)

# Enhanced country list
def get_country_list():
    return [
        'United States', 'USA', 'America', 'China', 'India', 'Japan', 'Germany', 'France',
        'United Kingdom', 'UK', 'Brazil', 'Russia', 'Canada', 'Australia', 'Mexico',
        'Italy', 'Spain', 'Turkey', 'Indonesia', 'Philippines', 'Pakistan', 'Bangladesh',
        'Nigeria', 'Egypt', 'Iran', 'Thailand', 'South Korea', 'Vietnam', 'Argentina',
        'Poland', 'Ukraine', 'Malaysia', 'Nepal', 'Afghanistan', 'Iraq', 'Syria',
        'South Africa', 'Kenya', 'Ethiopia', 'Morocco', 'Algeria', 'Sudan', 'Ghana',
        'Tanzania', 'Uganda', 'Mozambique', 'Madagascar', 'Cameroon', 'Angola', 'Chile',
        'Peru', 'Colombia', 'Venezuela', 'Ecuador', 'Bolivia', 'Paraguay', 'Uruguay',
        'Norway', 'Sweden', 'Finland', 'Denmark', 'Netherlands', 'Belgium', 'Switzerland',
        'Austria', 'Portugal', 'Greece', 'Czech Republic', 'Hungary', 'Romania', 'Bulgaria'
    ]

# Extract country from location using NER
def extract_country(text):
    if USE_NER:
        try:
            doc = nlp(text)
            countries = get_country_list()
            
            # First try to find countries in NER entities
            for ent in doc.ents:
                if ent.label_ == "GPE":
                    for country in countries:
                        if country.lower() in ent.text.lower():
                            return country
            
            # Fallback to text search
            text_upper = text.upper()
            for country in countries:
                if country.upper() in text_upper:
                    return country
        except Exception as e:
            print(f"Country extraction error: {e}")
    
    # Fallback method
    text_upper = text.upper()
    for country in get_country_list():
        if country.upper() in text_upper:
            return country
    return 'Unknown'

# Enhanced disaster type classification
def classify_disaster_type(text):
    text_lower = text.lower()
    
    # Score each disaster type based on keyword matches
    scores = {}
    for disaster_type, keywords in DISASTER_TYPES.items():
        score = 0
        for keyword in keywords:
            if keyword in text_lower:
                # Give higher weight to exact matches and longer keywords
                weight = len(keyword.split()) * 2 if len(keyword.split()) > 1 else 1
                score += weight
        scores[disaster_type] = score
    
    # Return the disaster type with the highest score
    if scores and max(scores.values()) > 0:
        best_match = max(scores, key=scores.get)
        return best_match.title()
    
    return 'Other'

# Enhanced additional information extraction
def extract_additional_info(text):
    info = {}
    
    # Enhanced people patterns
    people_patterns = [
        r'(\d+(?:,\d+)*)\s+(?:people|persons|individuals|victims|casualties)',
        r'(\d+(?:,\d+)*)\s+(?:killed|dead|deaths|fatalities)',
        r'(\d+(?:,\d+)*)\s+(?:injured|wounded|hurt)',
        r'(\d+(?:,\d+)*)\s+(?:missing|displaced|evacuated|affected)',
        r'(?:death toll|fatalities|casualties).*?(\d+(?:,\d+)*)',
        r'(\d+(?:,\d+)*)\s+(?:confirmed dead|reported dead)'
    ]
    
    for pattern in people_patterns:
        matches = re.findall(pattern, text.lower())
        if matches:
            info['affected_people'] = matches[0]
            break
    
    # Enhanced damage patterns
    damage_patterns = [
        r'\$(\d+(?:,\d+)*(?:\.\d+)?)\s*(?:million|billion|thousand|M|B|K)?',
        r'(\d+(?:,\d+)*(?:\.\d+)?)\s*(?:million|billion|thousand)\s*(?:dollars|USD|\$)',
        r'(?:damage|loss|cost).*?\$(\d+(?:,\d+)*(?:\.\d+)?)',
        r'(?:economic loss|financial impact).*?(\d+(?:,\d+)*)'
    ]
    
    for pattern in damage_patterns:
        matches = re.findall(pattern, text)
        if matches:
            info['damage_estimate'] = f"${matches[0]}"
            break
    
    # Extract magnitude for earthquakes
    magnitude_pattern = r'magnitude\s*(\d+(?:\.\d+)?)'
    magnitude_matches = re.findall(magnitude_pattern, text.lower())
    if magnitude_matches:
        info['magnitude'] = magnitude_matches[0]
    
    # Extract wind speed for hurricanes
    wind_pattern = r'wind.*?(\d+)\s*(?:mph|km/h|knots)'
    wind_matches = re.findall(wind_pattern, text.lower())
    if wind_matches:
        info['wind_speed'] = f"{wind_matches[0]} mph"
    
    return info

# Enhanced severity classification
def classify_severity(text, disaster_type):
    text = text.lower()
    
    # High severity keywords
    high_keywords = [
        'major', 'severe', 'catastrophic', 'emergency', 'devastating', 'massive',
        'deadly', 'fatal', 'critical', 'extreme', 'unprecedented', 'worst',
        'magnitude 7', 'magnitude 8', 'magnitude 9', 'category 4', 'category 5',
        'state of emergency', 'disaster declaration', 'evacuation order',
        'hundreds killed', 'thousands affected', 'widespread destruction'
    ]
    
    # Medium severity keywords
    medium_keywords = [
        'moderate', 'warning', 'alert', 'significant', 'notable', 'considerable',
        'magnitude 5', 'magnitude 6', 'category 2', 'category 3',
        'dozens injured', 'property damage', 'local emergency'
    ]
    
    # Calculate severity score
    high_score = sum(2 for word in high_keywords if word in text)
    medium_score = sum(1 for word in medium_keywords if word in text)
    
    if high_score >= 2 or any(word in text for word in ['catastrophic', 'devastating', 'emergency']):
        return 'High'
    elif high_score >= 1 or medium_score >= 2:
        return 'Medium'
    else:
        return 'Low'

# Enhanced data collection with event limit and mock data fallback
def collect_news_data():
    # Check if we've reached the limit
    current_count = get_event_count()
    if current_count >= MAX_EVENTS:
        print(f"Event limit reached ({current_count}/{MAX_EVENTS}). No more data collection needed.")
        return
    
    try:
        # First, clean up old news articles
        cleanup_old_news()
        
        # Recalculate current count after cleanup
        current_count = get_event_count()
        print(f"Current events after cleanup: {current_count}/{MAX_EVENTS}")
        
        # If we've reached the limit after cleanup, stop
        if current_count >= MAX_EVENTS:
            print(f"Event limit reached after cleanup ({current_count}/{MAX_EVENTS}). No more data collection needed.")
            return
        
        # Calculate how many new events we can add
        remaining_slots = MAX_EVENTS - current_count
        if remaining_slots <= 0:
            print("No slots available for new events")
            return
        
        new_events_added = 0
        api_failure_count = 0
        max_api_failures = 5  # After 5 failures, switch to mock data
        
        # Try to use real API first if mock data is not forced
        if not USE_MOCK_DATA:
            # Use expanded search queries but limit the number of new events
            for i, query in enumerate(SEARCH_QUERIES[:10]):  # Limit to first 10 queries to avoid rate limits
                if new_events_added >= remaining_slots:
                    print(f"Reached event limit. Added {new_events_added} new events.")
                    break
                    
                if api_failure_count >= max_api_failures:
                    print(f"Too many API failures ({api_failure_count}). Switching to mock data.")
                    break
                    
                try:
                    # Set date range to last MAX_NEWS_AGE_DAYS days
                    from_date = (datetime.now() - timedelta(days=MAX_NEWS_AGE_DAYS)).strftime('%Y-%m-%d')
                    to_date = datetime.now().strftime('%Y-%m-%d')
                    
                    url = f"https://newsapi.org/v2/everything?q={query}&apiKey={NEWS_API_KEY}&pageSize=2&sortBy=publishedAt&language=en&from={from_date}&to={to_date}"
                    response = requests.get(url, timeout=10)
                    
                    if response.status_code != 200:
                        print(f"API request failed for query {i+1}: {response.status_code}")
                        api_failure_count += 1
                        continue
                        
                    data = response.json()
                    
                    if 'articles' not in data:
                        print(f"No articles in response for query {i+1}")
                        api_failure_count += 1
                        continue
                    
                    for article in data.get('articles', []):
                        if new_events_added >= remaining_slots:
                            break
                            
                        title = article.get('title', '')
                        description = article.get('description', '') or ''
                        published_at = article.get('publishedAt', '')
                        
                        if not title or title == '[Removed]':
                            continue
                            
                        # Check if article is recent enough
                        if published_at:
                            try:
                                pub_date = datetime.fromisoformat(published_at.replace('Z', '+00:00'))
                                days_old = (datetime.now() - pub_date).days
                                if days_old > MAX_NEWS_AGE_DAYS:
                                    print(f"Skipping article that is {days_old} days old")
                                    continue
                            except Exception as e:
                                print(f"Error parsing date: {e}")
                        
                        content = title + " " + description
                        
                        # Check if article already exists
                        existing = execute_db_query('SELECT id FROM disasters WHERE title = %s', (title,), fetch='one')
                        if existing:
                            continue
                        
                        # Extract enhanced information
                        location = extract_location(content)
                        country = extract_country(content)
                        disaster_type = classify_disaster_type(content)
                        severity = classify_severity(content, disaster_type)
                        additional_info = extract_additional_info(content)
                        
                        # Use published_at as timestamp if available, otherwise use current time
                        timestamp = published_at if published_at else datetime.now().isoformat()
                        
                        # Insert new event
                        success = execute_db_query('''INSERT INTO disasters 
                                    (title, description, location, country, severity, disaster_type,
                                     source, timestamp, url, affected_people, damage_estimate, additional_info)
                                    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)''',
                                 (title, description, location, country, severity, disaster_type,
                                  article['source']['name'], timestamp,
                                  article.get('url', ''), 
                                  additional_info.get('affected_people', ''),
                                  additional_info.get('damage_estimate', ''),
                                  json.dumps(additional_info)))
                        
                        if success is not None:
                            new_events_added += 1
                            print(f"Added real event {new_events_added}: {title[:50]}...")
                    
                    # Small delay between requests to avoid rate limiting
                    time.sleep(1.0)  # Increased delay to 1 second
                    
                except Exception as e:
                    print(f"Error processing query {i+1}: {e}")
                    api_failure_count += 1
                    continue
        
        # If we still have slots and either USE_MOCK_DATA is True or we had API failures
        if new_events_added < remaining_slots and (USE_MOCK_DATA or api_failure_count >= max_api_failures):
            mock_count = min(remaining_slots - new_events_added, 10)  # Add up to 10 mock events at a time
            print(f"Adding {mock_count} mock disaster events...")
            mock_added = add_mock_disasters(mock_count)
            new_events_added += mock_added
        
        final_count = get_event_count()
        print(f"Data collection complete. Total events: {final_count}/{MAX_EVENTS}. Added: {new_events_added}")
        
        # If we've reached the limit, print a message
        if final_count >= MAX_EVENTS:
            print("EVENT LIMIT REACHED. No more data will be collected.")
        
    except Exception as e:
        print(f"Error collecting news: {e}")

# API Routes

@app.route('/api/disasters')
def get_disasters():
    result = execute_db_query('SELECT * FROM disasters ORDER BY timestamp DESC LIMIT 100', fetch='all')
    if not result:
        return jsonify([])
    
    disasters = []
    for row in result:
        disasters.append({
            'id': row[0],
            'title': row[1],
            'description': row[2],
            'location': row[3],
            'country': row[4],
            'severity': row[5],
            'disaster_type': row[6],
            'source': row[7],
            'timestamp': row[8],
            'url': row[9],
            'affected_people': row[10],
            'damage_estimate': row[11],
            'additional_info': row[12]
        })
    return jsonify(disasters)

@app.route('/api/stats')
def get_stats():
    # Count by severity
    severity_result = execute_db_query('SELECT severity, COUNT(*) FROM disasters GROUP BY severity', fetch='all')
    severity_stats = dict(severity_result) if severity_result else {}
    
    # Count by disaster type
    type_result = execute_db_query('SELECT disaster_type, COUNT(*) FROM disasters GROUP BY disaster_type ORDER BY COUNT(*) DESC', fetch='all')
    type_stats = dict(type_result) if type_result else {}
    
    # Count by country
    country_result = execute_db_query('SELECT country, COUNT(*) FROM disasters WHERE country != "Unknown" GROUP BY country ORDER BY COUNT(*) DESC LIMIT 10', fetch='all')
    country_stats = dict(country_result) if country_result else {}
    
    # Total count
    total_result = execute_db_query('SELECT COUNT(*) FROM disasters', fetch='one')
    total = total_result[0] if total_result else 0
    
    return jsonify({
        'total': total,
        'max_events': MAX_EVENTS,
        'max_age_days': MAX_NEWS_AGE_DAYS,
        'severity_breakdown': severity_stats,
        'type_breakdown': type_stats,
        'country_breakdown': country_stats
    })

@app.route('/api/alerts')
def get_alerts():
    result = execute_db_query('SELECT * FROM disasters WHERE severity = "High" ORDER BY timestamp DESC LIMIT 10', fetch='all')
    if not result:
        return jsonify([])
    
    alerts = []
    for row in result:
        alerts.append({
            'title': row[1],
            'description': row[2],
            'location': row[3],
            'disaster_type': row[6],
            'timestamp': row[8]
        })
    return jsonify(alerts)

# Debug route to check system status
@app.route('/debug/status')
def debug_status():
    # Get the oldest and newest article dates
    oldest_result = execute_db_query('SELECT timestamp FROM disasters ORDER BY timestamp ASC LIMIT 1', fetch='one')
    newest_result = execute_db_query('SELECT timestamp FROM disasters ORDER BY timestamp DESC LIMIT 1', fetch='one')
    
    oldest_date = oldest_result[0] if oldest_result else None
    newest_date = newest_result[0] if newest_result else None
    
    # Calculate date range
    date_range = None
    if oldest_date and newest_date:
        try:
            oldest = datetime.fromisoformat(oldest_date.replace('Z', '+00:00'))
            newest = datetime.fromisoformat(newest_date.replace('Z', '+00:00'))
            date_range = (newest - oldest).days
        except:
            date_range = "Error calculating"
    
    return jsonify({
        'ner_available': USE_NER,
        'using_mock_data': USE_MOCK_DATA,
        'current_events': get_event_count(),
        'max_events': MAX_EVENTS,
        'max_news_age_days': MAX_NEWS_AGE_DAYS,
        'oldest_article': oldest_date,
        'newest_article': newest_date,
        'date_range_days': date_range,
        'collection_status': "STOPPED" if get_event_count() >= MAX_EVENTS else "ACTIVE"
    })

# Route to manually generate mock data
@app.route('/debug/generate-mock/<int:count>')
def generate_mock(count):
    if count > 50:
        count = 50  # Limit to 50 at a time
    
    # Check if we've reached the limit
    current_count = get_event_count()
    if current_count >= MAX_EVENTS:
        return jsonify({
            'success': False,
            'message': f"Event limit reached ({current_count}/{MAX_EVENTS}). No more data will be collected.",
            'current_count': current_count,
            'max_events': MAX_EVENTS
        })
    
    # Calculate how many we can add
    count = min(count, MAX_EVENTS - current_count)
    added = add_mock_disasters(count)
    
    return jsonify({
        'success': True,
        'added': added,
        'current_count': get_event_count(),
        'max_events': MAX_EVENTS
    })

# Route to clear all data and start fresh
@app.route('/debug/clear-all')
def clear_all_data():
    """Clear all disaster data from the database"""
    try:
        execute_db_query('DELETE FROM disasters')
        return jsonify({
            'success': True,
            'message': 'All disaster data cleared',
            'current_count': get_event_count(),
            'max_events': MAX_EVENTS
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'message': f'Error clearing data: {e}',
            'current_count': get_event_count(),
            'max_events': MAX_EVENTS
        })

# Background data collection
def background_collector():
    """Background thread for collecting disaster data"""
    # Initial data collection with mock data to populate the database
    if get_event_count() == 0:
        print("Initial database population with mock data...")
        add_mock_disasters(20)  # Start with 20 mock events

    while True:
        try:
            # Check if we've reached the limit before collecting
            current_count = get_event_count()
            if current_count >= MAX_EVENTS:
                print(f"Event limit reached ({current_count}/{MAX_EVENTS}). Background collection stopped.")
                break  # Stop the background collector
            
            print("Starting data collection cycle...")
            collect_news_data()
            
            # Check again after collection
            if get_event_count() >= MAX_EVENTS:
                print(f"Event limit reached after collection. Background collection stopped.")
                break
                
        except Exception as e:
            print(f"Background collector error: {e}")
        
        # Wait 5 minutes before next collection cycle
        print("Waiting 5 minutes before next collection cycle...")
        time.sleep(300)  # Collect every 5 minutes
    
    print("Background data collection has stopped.")

@app.route('/')
def index():
    return render_template('landing.html')  # Changed to landing.html

@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        # Get form data (NOT JSON)
        name = request.form.get('name', '').strip()
        email = request.form.get('email', '').strip()
        password = request.form.get('password', '').strip()
        phone = request.form.get('phone', '').strip()
        location = request.form.get('location', '').strip()
        
        print(f"Received form data: Name={name}, Email={email}, Phone={phone}, Location={location}")
        
        # Validate
        if not all([name, email, password, phone, location]):
            flash('All fields are required!', 'error')
            return render_template('register.html')
        
        # Database operation
        conn = get_db_connection()
        if not conn:
            flash('Database connection failed!', 'error')
            return render_template('register.html')
        
        cursor = conn.cursor()
        try:
            # Check if email exists
            cursor.execute("SELECT Email FROM users WHERE Email = %s", (email,))
            if cursor.fetchone():
                flash('Email already exists! Please use a different email.', 'error')
                return render_template('register.html')
            
            # Insert user
            insert_query = """
            INSERT INTO users (Name, Email, Password, Phone, Location) 
            VALUES (%s, %s, %s, %s, %s)
            """
            cursor.execute(insert_query, (name, email, password, phone, location))
            conn.commit()
            
            print(f"✅ User {name} registered successfully!")
            flash('Registration successful! Please login.', 'success')
            return redirect(url_for('login'))
            
        except Exception as e:
            print(f"Registration error: {e}")
            flash(f'Registration failed: {str(e)}', 'error')
            
        finally:
            cursor.close()
            conn.close()
    
    return render_template('register.html')

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        email = request.form.get('email', '').strip()
        password = request.form.get('password', '').strip()
        
        print(f"Login attempt: {email},{password}")
        
        if not email or not password:
            flash('Email and password are required!', 'error')
            return render_template('login.html')
        
        conn = get_db_connection()
        if not conn:
            flash('Database connection failed!', 'error')
            return render_template('login.html')
        
        cursor = conn.cursor()
        try:
            cursor.execute("SELECT * FROM users WHERE Email = %s AND Password = %s", (email, password))
            user = cursor.fetchone()
            
            if user:
                session['user_id'] = user[0]
                session['user_name'] = user[1]
                session['user_email'] = user[2]
                print(f"✅ Login successful for: {user[1]}")
                flash(f'Welcome back, {user[1]}!', 'success')
                
                # Redirect to phpMyAdmin after successful login
                return redirect('/dashboard')
            else:
                flash('Invalid email or password!', 'error')
                
        except Exception as e:
            print(f"Login error: {e}")
            flash('Login failed!', 'error')
            
        finally:
            cursor.close()
            conn.close()
    
    return render_template('login.html')

@app.route('/dashboard')
def dashboard():
    if 'user_id' not in session:
        flash('Please login first!', 'error')
        return redirect(url_for('login'))
    
    return render_template('dashboard.html', user_name=session.get('user_name'))

@app.route('/logout')
def logout():
    session.clear()
    flash('You have been logged out successfully!', 'success')
    return redirect(url_for('index'))

@app.route('/test')
def test():
    conn = get_db_connection()
    if conn:
        cursor = conn.cursor()
        try:
            cursor.execute("SELECT COUNT(*) FROM users")
            count = cursor.fetchone()[0]
            cursor.execute("SELECT Name, Email, Phone, Location FROM users")
            users = cursor.fetchall()
            
            result = f"<h2>Database Test Results</h2>"
            result += f"<p><strong>Connection:</strong> ✅ Success</p>"
            result += f"<p><strong>Total Users:</strong> {count}</p>"
            result += f"<h3>Registered Users:</h3><ul>"
            
            for user in users:
                result += f"<li>{user[0]} - {user[1]} - {user[2]} - {user[3]}</li>"
            
            result += "</ul>"
            result += f"<p><a href='/'>← Back to Home</a></p>"
            
            return result
            
        except Exception as e:
            return f"<h2>Database Error</h2><p>{e}</p><p><a href='/'>← Back to Home</a></p>"
        finally:
            cursor.close()
            conn.close()
    else:
        return "<h2>Database Connection Failed!</h2><p>Please check your MySQL server.</p><p><a href='/'>← Back to Home</a></p>"

if __name__ == '__main__':
    print("Initializing Disaster Information System...")
    print(f"Maximum events: {MAX_EVENTS}")
    print(f"Maximum news age: {MAX_NEWS_AGE_DAYS} days")
    print(f"Using mock data: {USE_MOCK_DATA}")
    
    # Initialize database
    init_db()
    print("Database initialized.")
    
    # Start background data collection
    print("Starting background data collector...")
    collector_thread = threading.Thread(target=background_collector, daemon=True)
    collector_thread.start()
    
    print("Starting Flask web server...")
    print("Dashboard will be available at: http://localhost:5000")
    print("Debug status at: http://localhost:5000/debug/status")
    
    # Start Flask app
    app.run(debug=True, host='0.0.0.0', port=5000, use_reloader=False)