app.py

import gradio as gr
import plotly.graph_objects as go
import plotly.express as px
import pickle
import tropycal.tracks as tracks
import pandas as pd
import numpy as np
import cachetools
import functools
import hashlib
import os
import argparse
from datetime import datetime, timedelta
from datetime import date, datetime
from scipy import stats
from scipy.optimize import minimize, curve_fit
from sklearn.linear_model import LinearRegression
from sklearn.cluster import KMeans
from scipy.interpolate import interp1d
from fractions import Fraction
from concurrent.futures import ThreadPoolExecutor
from sklearn.metrics import mean_squared_error
import statsmodels.api as sm
import schedule
import time
import threading
import requests
from io import StringIO   
import tempfile
import csv  
from collections import defaultdict
import shutil
import filecmp

# Add command-line argument parsing
parser = argparse.ArgumentParser(description='Typhoon Analysis Dashboard')
parser.add_argument('--data_path', type=str, default=os.getcwd(), help='Path to the data directory')
args = parser.parse_args()

# Use the command-line argument for data path
DATA_PATH = args.data_path

ONI_DATA_PATH = os.path.join(DATA_PATH, 'oni_data.csv')
TYPHOON_DATA_PATH = os.path.join(DATA_PATH, 'processed_typhoon_data.csv')
LOCAL_iBtrace_PATH =  os.path.join(DATA_PATH, 'ibtracs.WP.list.v04r01.csv')
iBtrace_uri = 'https://www.ncei.noaa.gov/data/international-best-track-archive-for-climate-stewardship-ibtracs/v04r01/access/csv/ibtracs.WP.list.v04r01.csv'

CACHE_FILE = 'ibtracs_cache.pkl'
CACHE_EXPIRY_DAYS = 1
last_oni_update = None


def should_update_oni():
    today = datetime.now()
    # Beginning of the month: 1st day
    if today.day == 1:
        return True
    # Middle of the month: 15th day
    if today.day == 15:
        return True
    # End of the month: last day
    if today.day == (today.replace(day=1, month=today.month%12+1) - timedelta(days=1)).day:
        return True
    return False

color_map = {
    'C5 Super Typhoon': 'rgb(255, 0, 0)',      # Red
    'C4 Very Strong Typhoon': 'rgb(255, 63, 0)', # Red-Orange
    'C3 Strong Typhoon': 'rgb(255, 127, 0)',    # Orange
    'C2 Typhoon': 'rgb(255, 191, 0)',          # Orange-Yellow
    'C1 Typhoon': 'rgb(255, 255, 0)',          # Yellow
    'Tropical Storm': 'rgb(0, 255, 255)',       # Cyan
    'Tropical Depression': 'rgb(173, 216, 230)' # Light Blue
}

def convert_typhoondata(input_file, output_file):
    with open(input_file, 'r') as infile:
        # Skip the title and the unit line.
        next(infile)
        next(infile)
        
        reader = csv.reader(infile)
        
        # Used for storing data for each SID
        sid_data = defaultdict(list)
        
        for row in reader:
            if not row:  # Skip the blank lines
                continue
            
            sid = row[0]
            iso_time = row[6]
            sid_data[sid].append((row, iso_time))

    with open(output_file, 'w', newline='') as outfile:
        fieldnames = ['SID', 'ISO_TIME', 'LAT', 'LON', 'SEASON', 'NAME', 'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES', 'START_DATE', 'END_DATE']
        writer = csv.DictWriter(outfile, fieldnames=fieldnames)
        
        writer.writeheader()
        
        for sid, data in sid_data.items():
            start_date = min(data, key=lambda x: x[1])[1]
            end_date = max(data, key=lambda x: x[1])[1]
            
            for row, iso_time in data:
                writer.writerow({
                    'SID': row[0],
                    'ISO_TIME': iso_time,
                    'LAT': row[8],
                    'LON': row[9],
                    'SEASON': row[1],
                    'NAME': row[5],
                    'WMO_WIND': row[10].strip() or ' ',  
                    'WMO_PRES': row[11].strip() or ' ',
                    'USA_WIND': row[23].strip() or ' ',
                    'USA_PRES': row[24].strip() or ' ',
                    'START_DATE': start_date,
                    'END_DATE': end_date
                })


def download_oni_file(url, filename):
    print(f"Downloading file from {url}...")
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raises an exception for non-200 status codes
        with open(filename, 'wb') as f:
            f.write(response.content)
        print(f"File successfully downloaded and saved as {filename}")
        return True
    except requests.RequestException as e:
        print(f"Download failed. Error: {e}")
        return False


def convert_oni_ascii_to_csv(input_file, output_file):
    data = defaultdict(lambda: [''] * 12)
    season_to_month = {
        'DJF': 12, 'JFM': 1, 'FMA': 2, 'MAM': 3, 'AMJ': 4, 'MJJ': 5,
        'JJA': 6, 'JAS': 7, 'ASO': 8, 'SON': 9, 'OND': 10, 'NDJ': 11
    }
    
    print(f"Attempting to read file: {input_file}")
    try:
        with open(input_file, 'r') as f:
            lines = f.readlines()
            print(f"Successfully read {len(lines)} lines")
            
            if len(lines) <= 1:
                print("Error: File is empty or contains only header")
                return
            
            for line in lines[1:]:  # Skip header
                parts = line.split()
                if len(parts) >= 4:
                    season, year = parts[0], parts[1]
                    anom = parts[-1]
                    
                    if season in season_to_month:
                        month = season_to_month[season]
                        
                        if season == 'DJF':
                            year = str(int(year) - 1)
                        
                        data[year][month-1] = anom
                    else:
                        print(f"Warning: Unknown season: {season}")
                else:
                    print(f"Warning: Skipping invalid line: {line.strip()}")
            
            print(f"Processed data for {len(data)} years")
    except Exception as e:
        print(f"Error reading file: {e}")
        return

    print(f"Attempting to write file: {output_file}")
    try:
        with open(output_file, 'w', newline='') as f:
            writer = csv.writer(f)
            writer.writerow(['Year', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
            
            for year in sorted(data.keys()):
                row = [year] + data[year]
                writer.writerow(row)
            
            print(f"Successfully wrote {len(data)} rows of data")
    except Exception as e:
        print(f"Error writing file: {e}")
        return

    print(f"Conversion complete. Data saved to {output_file}")

def update_oni_data():
    global last_oni_update
    current_date = date.today()
    
    # Check if already updated today
    if last_oni_update == current_date:
        print("ONI data already checked today. Skipping update.")
        return
    
    url = "https://www.cpc.ncep.noaa.gov/data/indices/oni.ascii.txt"
    temp_file = os.path.join(DATA_PATH, "temp_oni.ascii.txt")
    input_file = os.path.join(DATA_PATH, "oni.ascii.txt")
    output_file = ONI_DATA_PATH
    
    if download_oni_file(url, temp_file):
        if not os.path.exists(input_file) or not filecmp.cmp(temp_file, input_file, shallow=False):
            # File doesn't exist or has been updated
            os.replace(temp_file, input_file)
            print("New ONI data detected. Converting to CSV.")
            convert_oni_ascii_to_csv(input_file, output_file)
            print("ONI data updated successfully.")
        else:
            print("ONI data is up to date. No conversion needed.")
            os.remove(temp_file)  # Remove temporary file
        
        last_oni_update = current_date
    else:
        print("Failed to download ONI data.")
        if os.path.exists(temp_file):
            os.remove(temp_file)  # Ensure cleanup of temporary file

def load_ibtracs_data():
    if os.path.exists(CACHE_FILE):
        cache_time = datetime.fromtimestamp(os.path.getmtime(CACHE_FILE))
        if datetime.now() - cache_time < timedelta(days=CACHE_EXPIRY_DAYS):
            print("Loading data from cache...")
            with open(CACHE_FILE, 'rb') as f:
                return pickle.load(f)
    
    if os.path.exists(LOCAL_iBtrace_PATH):
        print("Using local IBTrACS file...")
        ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
    else:
        print("Local IBTrACS file not found. Fetching data from remote server...")
        try:
            response = requests.get(iBtrace_uri)
            response.raise_for_status()
            
            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as temp_file:
                temp_file.write(response.text)
                temp_file_path = temp_file.name
            
            # Save the downloaded data as the local file
            shutil.move(temp_file_path, LOCAL_iBtrace_PATH)
            print(f"Downloaded data saved to {LOCAL_iBtrace_PATH}")
            
            ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
        except requests.RequestException as e:
            print(f"Error downloading data: {e}")
            print("No local file available and download failed. Unable to load IBTrACS data.")
            return None
    
    with open(CACHE_FILE, 'wb') as f:
        pickle.dump(ibtracs, f)
    
    return ibtracs
    
def update_ibtracs_data():
    global ibtracs
    print("Checking for IBTrACS data updates...")

    try:
        # Get the last-modified time of the remote file
        response = requests.head(iBtrace_uri)
        remote_last_modified = datetime.strptime(response.headers['Last-Modified'], '%a, %d %b %Y %H:%M:%S GMT')

        # Get the last-modified time of the local file
        if os.path.exists(LOCAL_iBtrace_PATH):
            local_last_modified = datetime.fromtimestamp(os.path.getmtime(LOCAL_iBtrace_PATH))
        else:
            local_last_modified = datetime.min

        # Compare the modification times
        if remote_last_modified <= local_last_modified:
            print("Local IBTrACS data is up to date. No update needed.")
            if os.path.exists(CACHE_FILE):
                # Update the cache file's timestamp to extend its validity
                os.utime(CACHE_FILE, None)
                print("Cache file timestamp updated.")
            return

        print("Remote data is newer. Updating IBTrACS data...")
        
        # Download the new data
        response = requests.get(iBtrace_uri)
        response.raise_for_status()
        
        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv') as temp_file:
            temp_file.write(response.text)
            temp_file_path = temp_file.name
        
        # Save the downloaded data as the local file
        shutil.move(temp_file_path, LOCAL_iBtrace_PATH)
        print(f"Downloaded data saved to {LOCAL_iBtrace_PATH}")
        
        # Update the last modified time of the local file to match the remote file
        os.utime(LOCAL_iBtrace_PATH, (remote_last_modified.timestamp(), remote_last_modified.timestamp()))
        
        ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
        
        with open(CACHE_FILE, 'wb') as f:
            pickle.dump(ibtracs, f)
        print("IBTrACS data updated and cache refreshed.")

    except requests.RequestException as e:
        print(f"Error checking or downloading data: {e}")
        if os.path.exists(LOCAL_iBtrace_PATH):
            print("Using existing local file.")
            ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', ibtracs_url=LOCAL_iBtrace_PATH)
            if os.path.exists(CACHE_FILE):
                # Update the cache file's timestamp even when using existing local file
                os.utime(CACHE_FILE, None)
                print("Cache file timestamp updated.")
        else:
            print("No local file available. Update failed.")

def run_schedule():
    while True:
        schedule.run_pending()
        time.sleep(1)

def analyze_typhoon_generation(merged_data, start_date, end_date):
    filtered_data = merged_data[
        (merged_data['ISO_TIME'] >= start_date) & 
        (merged_data['ISO_TIME'] <= end_date)
    ]
    
    filtered_data['ENSO_Phase'] = filtered_data['ONI'].apply(classify_enso_phases)
    
    typhoon_counts = filtered_data['ENSO_Phase'].value_counts().to_dict()
    
    month_counts = filtered_data.groupby(['ENSO_Phase', filtered_data['ISO_TIME'].dt.month]).size().unstack(fill_value=0)
    concentrated_months = month_counts.idxmax(axis=1).to_dict()
    
    return typhoon_counts, concentrated_months

def cache_key_generator(*args, **kwargs):
    key = hashlib.md5()
    for arg in args:
        key.update(str(arg).encode())
    for k, v in sorted(kwargs.items()):
        key.update(str(k).encode())
        key.update(str(v).encode())
    return key.hexdigest()

def categorize_typhoon(wind_speed):
    wind_speed_kt = wind_speed / 2  # Convert kt to m/s
    
    # Add category classification
    if wind_speed_kt >= 137/2.35:
        return 'C5 Super Typhoon'
    elif wind_speed_kt >= 113/2.35:
        return 'C4 Very Strong Typhoon' 
    elif wind_speed_kt >= 96/2.35:
        return 'C3 Strong Typhoon'
    elif wind_speed_kt >= 83/2.35:
        return 'C2 Typhoon'
    elif wind_speed_kt >= 64/2.35:
        return 'C1 Typhoon'
    elif wind_speed_kt >= 34/2.35:
        return 'Tropical Storm'
    else:
        return 'Tropical Depression'

@functools.lru_cache(maxsize=None)
def process_oni_data_cached(oni_data_hash):
    return process_oni_data(oni_data)

def process_oni_data(oni_data):
    oni_long = oni_data.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
    oni_long['Month'] = oni_long['Month'].map({
        'Jan': '01', 'Feb': '02', 'Mar': '03', 'Apr': '04', 'May': '05', 'Jun': '06',
        'Jul': '07', 'Aug': '08', 'Sep': '09', 'Oct': '10', 'Nov': '11', 'Dec': '12'
    })
    oni_long['Date'] = pd.to_datetime(oni_long['Year'].astype(str) + '-' + oni_long['Month'] + '-01')
    oni_long['ONI'] = pd.to_numeric(oni_long['ONI'], errors='coerce')
    return oni_long

def process_oni_data_with_cache(oni_data):
    oni_data_hash = cache_key_generator(oni_data.to_json())
    return process_oni_data_cached(oni_data_hash)

@functools.lru_cache(maxsize=None)
def process_typhoon_data_cached(typhoon_data_hash):
    return process_typhoon_data(typhoon_data)

def process_typhoon_data(typhoon_data):
    typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
    typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
    typhoon_data['USA_PRES'] = pd.to_numeric(typhoon_data['USA_PRES'], errors='coerce')
    typhoon_data['LON'] = pd.to_numeric(typhoon_data['LON'], errors='coerce')
    
    typhoon_max = typhoon_data.groupby('SID').agg({
        'USA_WIND': 'max',
        'USA_PRES': 'min',
        'ISO_TIME': 'first',
        'SEASON': 'first',
        'NAME': 'first',
        'LAT': 'first',
        'LON': 'first'
    }).reset_index()
    
    typhoon_max['Month'] = typhoon_max['ISO_TIME'].dt.strftime('%m')
    typhoon_max['Year'] = typhoon_max['ISO_TIME'].dt.year
    typhoon_max['Category'] = typhoon_max['USA_WIND'].apply(categorize_typhoon)
    return typhoon_max

def process_typhoon_data_with_cache(typhoon_data):
    typhoon_data_hash = cache_key_generator(typhoon_data.to_json())
    return process_typhoon_data_cached(typhoon_data_hash)

def merge_data(oni_long, typhoon_max):
    return pd.merge(typhoon_max, oni_long, on=['Year', 'Month'])

def calculate_logistic_regression(merged_data):
    data = merged_data.dropna(subset=['USA_WIND', 'ONI'])
    
    # Create binary outcome for severe typhoons
    data['severe_typhoon'] = (data['USA_WIND'] >= 51).astype(int)
    
    # Create binary predictor for El Niño
    data['el_nino'] = (data['ONI'] >= 0.5).astype(int)
    
    X = data['el_nino']
    X = sm.add_constant(X)  # Add constant term
    y = data['severe_typhoon']
    
    model = sm.Logit(y, X).fit()
    
    beta_1 = model.params['el_nino']
    exp_beta_1 = np.exp(beta_1)
    p_value = model.pvalues['el_nino']
    
    return beta_1, exp_beta_1, p_value

@cachetools.cached(cache={})
def fetch_oni_data_from_csv(file_path):
    df = pd.read_csv(file_path, sep=',', header=0, na_values='-99.90')
    df.columns = ['Year', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
    df = df.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
    df['Date'] = pd.to_datetime(df['Year'].astype(str) + df['Month'], format='%Y%b')
    df = df.set_index('Date')
    return df

def classify_enso_phases(oni_value):
    if isinstance(oni_value, pd.Series):
        oni_value = oni_value.iloc[0]
    if oni_value >= 0.5:
        return 'El Nino'
    elif oni_value <= -0.5:
        return 'La Nina'
    else:
        return 'Neutral'

def load_data(oni_data_path, typhoon_data_path):
    oni_data = pd.read_csv(oni_data_path)
    typhoon_data = pd.read_csv(typhoon_data_path, low_memory=False)
    
    typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
    
    typhoon_data = typhoon_data.dropna(subset=['ISO_TIME'])
    
    print(f"Typhoon data shape after cleaning: {typhoon_data.shape}")
    print(f"Year range: {typhoon_data['ISO_TIME'].dt.year.min()} - {typhoon_data['ISO_TIME'].dt.year.max()}")
    
    return oni_data, typhoon_data

def preprocess_data(oni_data, typhoon_data):
    typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
    typhoon_data['WMO_PRES'] = pd.to_numeric(typhoon_data['WMO_PRES'], errors='coerce')
    typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'], errors='coerce')
    typhoon_data['Year'] = typhoon_data['ISO_TIME'].dt.year
    typhoon_data['Month'] = typhoon_data['ISO_TIME'].dt.month
    
    monthly_max_wind_speed = typhoon_data.groupby(['Year', 'Month'])['USA_WIND'].max().reset_index()
    
    oni_data_long = pd.melt(oni_data, id_vars=['Year'], var_name='Month', value_name='ONI')
    oni_data_long['Month'] = oni_data_long['Month'].apply(lambda x: pd.to_datetime(x, format='%b').month)
    
    merged_data = pd.merge(monthly_max_wind_speed, oni_data_long, on=['Year', 'Month'])
    
    return merged_data

def calculate_max_wind_min_pressure(typhoon_data):
    max_wind_speed = typhoon_data['USA_WIND'].max()
    min_pressure = typhoon_data['WMO_PRES'].min()
    return max_wind_speed, min_pressure

@functools.lru_cache(maxsize=None)
def get_storm_data(storm_id):
    return ibtracs.get_storm(storm_id)

def filter_west_pacific_coordinates(lons, lats):
    mask = (100 <= lons) & (lons <= 180) & (0 <= lats) & (lats <= 40)
    return lons[mask], lats[mask]

def polynomial_exp(x, a, b, c, d):
    return a * x**2 + b * x + c + d * np.exp(x)

def exponential(x, a, b, c):
    return a * np.exp(b * x) + c

def generate_cluster_equations(cluster_center):
    X = cluster_center[:, 0]  # Longitudes
    y = cluster_center[:, 1]  # Latitudes
    
    x_min = X.min()
    x_max = X.max()
    
    equations = []

    # Fourier Series (up to 4th order)
    def fourier_series(x, a0, a1, b1, a2, b2, a3, b3, a4, b4):
        return (a0 + a1*np.cos(x) + b1*np.sin(x) + 
                a2*np.cos(2*x) + b2*np.sin(2*x) + 
                a3*np.cos(3*x) + b3*np.sin(3*x) + 
                a4*np.cos(4*x) + b4*np.sin(4*x))

    # Normalize X to the range [0, 2π]
    X_normalized = 2 * np.pi * (X - x_min) / (x_max - x_min)

    params, _ = curve_fit(fourier_series, X_normalized, y)
    a0, a1, b1, a2, b2, a3, b3, a4, b4 = params
    
    # Create the equation string
    fourier_eq = (f"y = {a0:.4f} + {a1:.4f}*cos(x) + {b1:.4f}*sin(x) + "
                  f"{a2:.4f}*cos(2x) + {b2:.4f}*sin(2x) + "
                  f"{a3:.4f}*cos(3x) + {b3:.4f}*sin(3x) + "
                  f"{a4:.4f}*cos(4x) + {b4:.4f}*sin(4x)")
    
    equations.append(("Fourier Series", fourier_eq))
    equations.append(("X Range", f"x goes from 0 to {2*np.pi:.4f}"))
    equations.append(("Longitude Range", f"Longitude goes from {x_min:.4f}°E to {x_max:.4f}°E"))

    return equations, (x_min, x_max)
    



# Classification standards
atlantic_standard = {
    'C5 Super Typhoon': {'wind_speed': 137, 'color': 'rgb(255, 0, 0)'},      
    'C4 Very Strong Typhoon': {'wind_speed': 113, 'color': 'rgb(255, 63, 0)'}, 
    'C3 Strong Typhoon': {'wind_speed': 96, 'color': 'rgb(255, 127, 0)'},    
    'C2 Typhoon': {'wind_speed': 83, 'color': 'rgb(255, 191, 0)'},          
    'C1 Typhoon': {'wind_speed': 64, 'color': 'rgb(255, 255, 0)'},          
    'Tropical Storm': {'wind_speed': 34, 'color': 'rgb(0, 255, 255)'},       
    'Tropical Depression': {'wind_speed': 0, 'color': 'rgb(173, 216, 230)'}  
}

taiwan_standard = {
    'Strong Typhoon': {'wind_speed': 51.0, 'color': 'rgb(255, 0, 0)'},       # >= 51.0 m/s
    'Medium Typhoon': {'wind_speed': 33.7, 'color': 'rgb(255, 127, 0)'},     # 33.7-50.9 m/s
    'Mild Typhoon': {'wind_speed': 17.2, 'color': 'rgb(255, 255, 0)'},       # 17.2-33.6 m/s
    'Tropical Depression': {'wind_speed': 0, 'color': 'rgb(173, 216, 230)'}  # < 17.2 m/s
}

def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
    """
    Categorize typhoon based on wind speed and chosen standard
    wind_speed is in knots
    """
    if standard == 'taiwan':
        # Convert knots to m/s for Taiwan standard
        wind_speed_ms = wind_speed * 0.514444
        
        if wind_speed_ms >= 51.0:
            return 'Strong Typhoon', taiwan_standard['Strong Typhoon']['color']
        elif wind_speed_ms >= 33.7:
            return 'Medium Typhoon', taiwan_standard['Medium Typhoon']['color']
        elif wind_speed_ms >= 17.2:
            return 'Mild Typhoon', taiwan_standard['Mild Typhoon']['color']
        else:
            return 'Tropical Depression', taiwan_standard['Tropical Depression']['color']
    else:
        # Atlantic standard uses knots
        if wind_speed >= 137:
            return 'C5 Super Typhoon', atlantic_standard['C5 Super Typhoon']['color']
        elif wind_speed >= 113:
            return 'C4 Very Strong Typhoon', atlantic_standard['C4 Very Strong Typhoon']['color']
        elif wind_speed >= 96:
            return 'C3 Strong Typhoon', atlantic_standard['C3 Strong Typhoon']['color']
        elif wind_speed >= 83:
            return 'C2 Typhoon', atlantic_standard['C2 Typhoon']['color']
        elif wind_speed >= 64:
            return 'C1 Typhoon', atlantic_standard['C1 Typhoon']['color']
        elif wind_speed >= 34:
            return 'Tropical Storm', atlantic_standard['Tropical Storm']['color']
        else:
            return 'Tropical Depression', atlantic_standard['Tropical Depression']['color']

# Initialize data at startup
def initialize_data():
    global oni_df, ibtracs, oni_data, typhoon_data, oni_long, typhoon_max, merged_data, data, max_wind_speed, min_pressure
    
    print(f"Using data path: {DATA_PATH}")
    # Update ONI data before starting the application
    update_oni_data()
    oni_df = fetch_oni_data_from_csv(ONI_DATA_PATH)
    ibtracs = load_ibtracs_data()
    
    if os.path.exists(LOCAL_iBtrace_PATH):
        convert_typhoondata(LOCAL_iBtrace_PATH, TYPHOON_DATA_PATH)
    
    oni_data, typhoon_data = load_data(ONI_DATA_PATH, TYPHOON_DATA_PATH)
    oni_long = process_oni_data(oni_data)
    typhoon_max = process_typhoon_data(typhoon_data)
    merged_data = merge_data(oni_long, typhoon_max)
    data = preprocess_data(oni_data, typhoon_data)
    max_wind_speed, min_pressure = calculate_max_wind_min_pressure(typhoon_data)
    
    # Schedule data updates
    schedule.every().day.at("01:00").do(update_ibtracs_data)
    schedule.every().day.at("00:00").do(lambda: update_oni_data() if should_update_oni() else None)
    
    # Run the scheduler in a separate thread
    scheduler_thread = threading.Thread(target=run_schedule)
    scheduler_thread.daemon = True
    scheduler_thread.start()
    
    return oni_df, ibtracs, typhoon_data

# Function to get available years from typhoon data
def get_available_years():
    if typhoon_data is None:
        return []
    years = typhoon_data['ISO_TIME'].dt.year.unique()
    years = years[~np.isnan(years)]
    years = sorted(years)
    return years

# Function to get available typhoons for a selected year
def get_typhoons_for_year(year):
    if not year or ibtracs is None:
        return []
    
    try:
        year = int(year)
        season = ibtracs.get_season(year)
        storm_summary = season.summary()
        
        typhoon_options = []
        for i in range(storm_summary['season_storms']):
            storm_id = storm_summary['id'][i]
            storm_name = storm_summary['name'][i]
            typhoon_options.append((f"{storm_name} ({storm_id})", storm_id))
        
        return typhoon_options
    except Exception as e:
        print(f"Error getting typhoons for year {year}: {e}")
        return []

# Create animation for typhoon path
def create_typhoon_path_animation(year, typhoon_id, standard):
    if not year or not typhoon_id:
        return None
    
    try:
        storm = ibtracs.get_storm(typhoon_id)
        fig = go.Figure()

        fig.add_trace(
            go.Scattergeo(
                lon=storm.lon,
                lat=storm.lat,
                mode='lines',
                line=dict(width=2, color='gray'),
                name='Path',
                showlegend=False,
            )
        )

        fig.add_trace(
            go.Scattergeo(
                lon=[storm.lon[0]],
                lat=[storm.lat[0]],
                mode='markers',
                marker=dict(size=10, color='green', symbol='star'),
                name='Starting Point',
                text=storm.time[0].strftime('%Y-%m-%d %H:%M'),
                hoverinfo='text+name',
            )
        )

        frames = []
        for i in range(len(storm.time)):
            category, color = categorize_typhoon_by_standard(storm.vmax[i], standard)
            
            # Get additional data if available
            r34_ne = storm.dict['USA_R34_NE'][i] if 'USA_R34_NE' in storm.dict else None
            r34_se = storm.dict['USA_R34_SE'][i] if 'USA_R34_SE' in storm.dict else None
            r34_sw = storm.dict['USA_R34_SW'][i] if 'USA_R34_SW' in storm.dict else None
            r34_nw = storm.dict['USA_R34_NW'][i] if 'USA_R34_NW' in storm.dict else None
            rmw = storm.dict['USA_RMW'][i] if 'USA_RMW' in storm.dict else None
            eye_diameter = storm.dict['USA_EYE'][i] if 'USA_EYE' in storm.dict else None

            radius_info = f"R34: NE={r34_ne}, SE={r34_se}, SW={r34_sw}, NW={r34_nw}<br>"
            radius_info += f"RMW: {rmw}<br>"
            radius_info += f"Eye Diameter: {eye_diameter}"
            
            frame_data = [
                go.Scattergeo(
                    lon=storm.lon[:i+1],
                    lat=storm.lat[:i+1],
                    mode='lines',
                    line=dict(width=2, color='blue'),
                    name='Path Traveled',
                    showlegend=False,
                ),
                go.Scattergeo(
                    lon=[storm.lon[i]],
                    lat=[storm.lat[i]],
                    mode='markers+text',
                    marker=dict(size=10, color=color, symbol='star'),
                    text=category,
                    textposition="top center",
                    textfont=dict(size=12, color=color),
                    name='Current Location',
                    hovertext=f"{storm.time[i].strftime('%Y-%m-%d %H:%M')}<br>"
                              f"Category: {category}<br>"
                              f"Wind Speed: {storm.vmax[i]:.1f} m/s<br>"
                              f"{radius_info}",
                    hoverinfo='text',
                ),
            ]
            frames.append(go.Frame(data=frame_data, name=f"frame{i}"))

        fig.frames = frames

        fig.update_layout(
            title=f"{year} Year {storm.name} Typhoon Path",
            showlegend=False,
            geo=dict(
                projection_type='natural earth',
                showland=True,
                landcolor='rgb(243, 243, 243)',
                countrycolor='rgb(204, 204, 204)',
                coastlinecolor='rgb(100, 100, 100)',
                showocean=True,
                oceancolor='rgb(230, 250, 255)',
            ),
            updatemenus=[{
                "buttons": [
                    {
                        "args": [None, {"frame": {"duration": 100, "redraw": True},
                                        "fromcurrent": True,
                                        "transition": {"duration": 0}}],
                        "label": "Play",
                        "method": "animate"
                    },
                    {
                        "args": [[None], {"frame": {"duration": 0, "redraw": True},
                                          "mode": "immediate",
                                          "transition": {"duration": 0}}],
                        "label": "Pause",
                        "method": "animate"
                    }
                ],
                "direction": "left",
                "pad": {"r": 10, "t": 87},
                "showactive": False,
                "type": "buttons",
                "x": 0.1,
                "xanchor": "right",
                "y": 0,
                "yanchor": "top"
            }],
            sliders=[{
                "active": 0,
                "yanchor": "top",
                "xanchor": "left",
                "currentvalue": {
                    "font": {"size": 20},
                    "prefix": "Time: ",
                    "visible": True,
                    "xanchor": "right"
                },
                "transition": {"duration": 100, "easing": "cubic-in-out"},
                "pad": {"b": 10, "t": 50},
                "len": 0.9,
                "x": 0.1,
                "y": 0,
                "steps": [
                    {
                        "args": [[f"frame{k}"],
                                {"frame": {"duration": 100, "redraw": True},
                                  "mode": "immediate",
                                  "transition": {"duration": 0}}
                                ],
                        "label": storm.time[k].strftime('%Y-%m-%d %H:%M'),
                        "method": "animate"
                    }
                    for k in range(len(storm.time))
                ]
            }]
        )

        return fig
    except Exception as e:
        print(f"Error creating typhoon path animation: {e}")
        return None

# Function to analyze typhoon tracks 
def analyze_typhoon_tracks(start_year, start_month, end_year, end_month, enso_selection, typhoon_search=""):
    start_date = datetime(int(start_year), int(start_month), 1)
    end_date = datetime(int(end_year), int(end_month), 28)
    
    # Create typhoon tracks plot
    fig_tracks = go.Figure()
    
    # Map Gradio dropdown values to the values used in the original code
    enso_map = {
        "All Years": "all", 
        "El Niño Years": "el_nino", 
        "La Niña Years": "la_nina", 
        "Neutral Years": "neutral"
    }
    enso_value = enso_map[enso_selection]
    
    try:
        for year in range(int(start_year), int(end_year) + 1):
            if year not in ibtracs.data.keys():
                continue
            
            season = ibtracs.get_season(year)
            for storm_id in season.summary()['id']:
                storm = get_storm_data(storm_id)
                storm_dates = storm.time
                
                if any(start_date <= date <= end_date for date in storm_dates):
                    storm_date_str = storm_dates[0].strftime('%Y-%b')
                    if storm_date_str in oni_df.index:
                        storm_oni = oni_df.loc[storm_date_str]['ONI']
                        if isinstance(storm_oni, pd.Series):
                            storm_oni = storm_oni.iloc[0]
                        
                        phase = classify_enso_phases(storm_oni)
                        
                        if (enso_value == 'all' or 
                            (enso_value == 'el_nino' and phase == 'El Nino') or
                            (enso_value == 'la_nina' and phase == 'La Nina') or
                            (enso_value == 'neutral' and phase == 'Neutral')):
                            
                            color = {'El Nino': 'red', 'La Nina': 'blue', 'Neutral': 'green'}[phase]
                            
                            # Highlight searched typhoon
                            if typhoon_search and typhoon_search.lower() in storm.name.lower():
                                line_width = 5
                                line_color = 'yellow'
                            else:
                                line_width = 2
                                line_color = color
                            
                            fig_tracks.add_trace(go.Scattergeo(
                                lon=storm.lon,
                                lat=storm.lat,
                                mode='lines',
                                name=storm.name,
                                text=f'{storm.name} ({year})',
                                hoverinfo='text',
                                line=dict(width=line_width, color=line_color)
                            ))
        
        fig_tracks.update_layout(
            title=f'Typhoon Tracks from {start_year}-{start_month} to {end_year}-{end_month}',
            geo=dict(
                projection_type='natural earth',
                showland=True,
                coastlinecolor='rgb(100, 100, 100)',
                countrycolor='rgb(204, 204, 204)',
            )
        )
        
        # Calculate statistics for this period
        filtered_data = merged_data[
            (merged_data['Year'] >= int(start_year)) & 
            (merged_data['Year'] <= int(end_year)) & 
            (merged_data['Month'].astype(int) >= int(start_month)) & 
            (merged_data['Month'].astype(int) <= int(end_month))
        ]
        
        max_wind = filtered_data['USA_WIND'].max() if not filtered_data.empty else 0
        min_press = filtered_data['USA_PRES'].min() if not filtered_data.empty else 0
        
        stats_text = f"Maximum Wind Speed: {max_wind:.2f} knots\nMinimum Pressure: {min_press:.2f} hPa"
        
        # Create wind scatter plot
        wind_oni_scatter = px.scatter(filtered_data, x='ONI', y='USA_WIND', color='Category',
                                    hover_data=['NAME', 'Year', 'Category'],
                                    title='Wind Speed vs ONI',
                                    labels={'ONI': 'ONI Value', 'USA_WIND': 'Maximum Wind Speed (knots)'},
                                    color_discrete_map=color_map)
        
        # Create pressure scatter plot
        pressure_oni_scatter = px.scatter(filtered_data, x='ONI', y='USA_PRES', color='Category',
                                        hover_data=['NAME', 'Year', 'Category'],
                                        title='Pressure vs ONI',
                                        labels={'ONI': 'ONI Value', 'USA_PRES': 'Minimum Pressure (hPa)'},
                                        color_discrete_map=color_map)
        
        return fig_tracks, wind_oni_scatter, pressure_oni_scatter, stats_text
    except Exception as e:
        error_fig = go.Figure()
        error_fig.add_annotation(text=f"Error: {str(e)}", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
        return error_fig, error_fig, error_fig, f"Error analyzing typhoon tracks: {str(e)}"

# Function to run cluster analysis
def run_cluster_analysis(start_year, start_month, end_year, end_month, n_clusters, enso_selection, analysis_type):
    start_date = datetime(int(start_year), int(start_month), 1)
    end_date = datetime(int(end_year), int(end_month), 28)
    
    # Map Gradio dropdown values to the values used in the original code
    enso_map = {
        "All Years": "all", 
        "El Niño Years": "el_nino", 
        "La Niña Years": "la_nina", 
        "Neutral Years": "neutral"
    }
    enso_value = enso_map[enso_selection]
    
    fig_routes = go.Figure()
    
    try:
        # Clustering analysis
        west_pacific_storms = []
        for year in range(int(start_year), int(end_year) + 1):
            if year not in ibtracs.data.keys():
                continue
            
            season = ibtracs.get_season(year)
            for storm_id in season.summary()['id']:
                storm = get_storm_data(storm_id)
                storm_date = storm.time[0]
                
                # Try to find the ONI value for this storm date
                date_str = storm_date.strftime('%Y-%b')
                if date_str in oni_df.index:
                    storm_oni = oni_df.loc[date_str]['ONI']
                    if isinstance(storm_oni, pd.Series):
                        storm_oni = storm_oni.iloc[0]
                    storm_phase = classify_enso_phases(storm_oni)
                    
                    if enso_value == 'all' or \
                       (enso_value == 'el_nino' and storm_phase == 'El Nino') or \
                       (enso_value == 'la_nina' and storm_phase == 'La Nina') or \
                       (enso_value == 'neutral' and storm_phase == 'Neutral'):
                        lons, lats = filter_west_pacific_coordinates(np.array(storm.lon), np.array(storm.lat))
                        if len(lons) > 1:  # Ensure the storm has a valid path in West Pacific
                            west_pacific_storms.append((lons, lats))
        
        if not west_pacific_storms:
            return None, "No storms found matching the criteria"
        
        max_length = max(len(storm[0]) for storm in west_pacific_storms)
        standardized_routes = []
        
        for lons, lats in west_pacific_storms:
            if len(lons) < 2:  # Skip if not enough points
                continue
            t = np.linspace(0, 1, len(lons))
            t_new = np.linspace(0, 1, max_length)
            lon_interp = interp1d(t, lons, kind='linear')(t_new)
            lat_interp = interp1d(t, lats, kind='linear')(t_new)
            route_vector = np.column_stack((lon_interp, lat_interp)).flatten()
            standardized_routes.append(route_vector)
        
        if not standardized_routes:
            return None, "Unable to create standardized routes"
        
        kmeans = KMeans(n_clusters=int(n_clusters), random_state=42, n_init=10)
        clusters = kmeans.fit_predict(standardized_routes)
        
        # Count the number of typhoons in each cluster
        cluster_counts = np.bincount(clusters)
        
        # Draw all routes (with lighter color)
        if analysis_type == "Show Routes":
            for lons, lats in west_pacific_storms:
                fig_routes.add_trace(go.Scattergeo(
                    lon=lons, lat=lats,
                    mode='lines',
                    line=dict(width=1, color='lightgray'),
                    showlegend=False,
                    hoverinfo='none'
                ))
        
        equations_output = ""
        # Draw cluster centroids
        if analysis_type == "Show Clusters" or analysis_type == "Fourier Series":
            for i in range(int(n_clusters)):
                cluster_center = kmeans.cluster_centers_[i].reshape(-1, 2)
                
                fig_routes.add_trace(go.Scattergeo(
                    lon=cluster_center[:, 0],
                    lat=cluster_center[:, 1],
                    mode='lines',
                    name=f'Cluster {i+1} (n={cluster_counts[i]})',
                    line=dict(width=3)
                ))
                
                if analysis_type == "Fourier Series":
                    cluster_equations, (lon_min, lon_max) = generate_cluster_equations(cluster_center)
                    
                    equations_output += f"\n--- Cluster {i+1} (Typhoons: {cluster_counts[i]}) ---\n"
                    for name, eq in cluster_equations:
                        equations_output += f"{name}: {eq}\n"
                    
                    equations_output += "\nTo use in GeoGebra:\n"
                    equations_output += f"1. Set x-axis from 0 to {2*np.pi:.4f}\n"
                    equations_output += "2. Use the equation as is\n"
                    equations_output += f"3. To convert x back to longitude: lon = {lon_min:.4f} + x * {(lon_max - lon_min) / (2*np.pi):.4f}\n\n"
        
        enso_phase_text = {
            'all': 'All Years',
            'el_nino': 'El Niño Years',
            'la_nina': 'La Niña Years',
            'neutral': 'Neutral Years'
        }
        
        fig_routes.update_layout(
            title=f'Typhoon Routes Clustering in West Pacific ({start_year}-{end_year}) - {enso_phase_text[enso_value]}',
            geo=dict(
                projection_type='mercator',
                showland=True,
                landcolor='rgb(243, 243, 243)',
                countrycolor='rgb(204, 204, 204)',
                coastlinecolor='rgb(100, 100, 100)',
                showocean=True,
                oceancolor='rgb(230, 250, 255)',
                lataxis={'range': [0, 40]},
                lonaxis={'range': [100, 180]},
                center={'lat': 20, 'lon': 140},
            ),
            legend_title='Clusters'
        )
        
        return fig_routes, equations_output
    except Exception as e:
        error_fig = go.Figure()
        error_fig.add_annotation(text=f"Error: {str(e)}", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
        return error_fig, f"Error in cluster analysis: {str(e)}"

# Function to perform logistic regression
def perform_logistic_regression(start_year, start_month, end_year, end_month, regression_type):
    start_date = datetime(int(start_year), int(start_month), 1)
    end_date = datetime(int(end_year), int(end_month), 28)
    
    try:
        filtered_data = merged_data[
            (merged_data['ISO_TIME'] >= start_date) & 
            (merged_data['ISO_TIME'] <= end_date)
        ]
        
        if regression_type == "Wind Speed":
            filtered_data['severe_typhoon'] = (filtered_data['USA_WIND'] >= 64).astype(int)  # 64 knots threshold for severe typhoons
            X = sm.add_constant(filtered_data['ONI'])
            y = filtered_data['severe_typhoon']
            model = sm.Logit(y, X).fit()
            
            beta_1 = model.params['ONI']
            exp_beta_1 = np.exp(beta_1)
            p_value = model.pvalues['ONI']
            
            el_nino_data = filtered_data[filtered_data['ONI'] >= 0.5]
            la_nina_data = filtered_data[filtered_data['ONI'] <= -0.5]
            neutral_data = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]
            
            el_nino_severe = el_nino_data['severe_typhoon'].mean() if not el_nino_data.empty else 0
            la_nina_severe = la_nina_data['severe_typhoon'].mean() if not la_nina_data.empty else 0
            neutral_severe = neutral_data['severe_typhoon'].mean() if not neutral_data.empty else 0
            
            result = f"""
            # Wind Speed Logistic Regression Results
            
            β1 (ONI coefficient): {beta_1:.4f}
            exp(β1) (Odds Ratio): {exp_beta_1:.4f}
            P-value: {p_value:.4f}
            
            Interpretation:
            - For each unit increase in ONI, the odds of a severe typhoon are {"increased" if exp_beta_1 > 1 else "decreased"} by a factor of {exp_beta_1:.2f}.
            - This effect is {"statistically significant" if p_value < 0.05 else "not statistically significant"} at the 0.05 level.
            
            Proportion of severe typhoons:
            - El Niño conditions: {el_nino_severe:.2%}
            - La Niña conditions: {la_nina_severe:.2%}
            - Neutral conditions: {neutral_severe:.2%}
            """
            
        elif regression_type == "Pressure":
            filtered_data['intense_typhoon'] = (filtered_data['USA_PRES'] <= 950).astype(int)  # 950 hPa threshold for intense typhoons
            X = sm.add_constant(filtered_data['ONI'])
            y = filtered_data['intense_typhoon']
            model = sm.Logit(y, X).fit()
            
            beta_1 = model.params['ONI']
            exp_beta_1 = np.exp(beta_1)
            p_value = model.pvalues['ONI']
            
            el_nino_data = filtered_data[filtered_data['ONI'] >= 0.5]
            la_nina_data = filtered_data[filtered_data['ONI'] <= -0.5]
            neutral_data = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]
            
            el_nino_intense = el_nino_data['intense_typhoon'].mean() if not el_nino_data.empty else 0
            la_nina_intense = la_nina_data['intense_typhoon'].mean() if not la_nina_data.empty else 0
            neutral_intense = neutral_data['intense_typhoon'].mean() if not neutral_data.empty else 0
            
            result = f"""
            # Pressure Logistic Regression Results
            
            β1 (ONI coefficient): {beta_1:.4f}
            exp(β1) (Odds Ratio): {exp_beta_1:.4f}
            P-value: {p_value:.4f}
            
            Interpretation:
            - For each unit increase in ONI, the odds of an intense typhoon (pressure <= 950 hPa) are {"increased" if exp_beta_1 > 1 else "decreased"} by a factor of {exp_beta_1:.2f}.
            - This effect is {"statistically significant" if p_value < 0.05 else "not statistically significant"} at the 0.05 level.
            
            Proportion of intense typhoons:
            - El Niño conditions: {el_nino_intense:.2%}
            - La Niña conditions: {la_nina_intense:.2%}
            - Neutral conditions: {neutral_intense:.2%}
            """
            
        elif regression_type == "Longitude":
            filtered_data = filtered_data.dropna(subset=['LON'])
            
            if len(filtered_data) == 0:
                return "Insufficient data for longitude analysis"
            
            filtered_data['western_typhoon'] = (filtered_data['LON'] <= 140).astype(int)  # 140°E as threshold for western typhoons
            X = sm.add_constant(filtered_data['ONI'])
            y = filtered_data['western_typhoon']
            model = sm.Logit(y, X).fit()
            
            beta_1 = model.params['ONI']
            exp_beta_1 = np.exp(beta_1)
            p_value = model.pvalues['ONI']
            
            el_nino_data = filtered_data[filtered_data['ONI'] >= 0.5]
            la_nina_data = filtered_data[filtered_data['ONI'] <= -0.5]
            neutral_data = filtered_data[(filtered_data['ONI'] > -0.5) & (filtered_data['ONI'] < 0.5)]
            
            el_nino_western = el_nino_data['western_typhoon'].mean() if not el_nino_data.empty else 0
            la_nina_western = la_nina_data['western_typhoon'].mean() if not la_nina_data.empty else 0
            neutral_western = neutral_data['western_typhoon'].mean() if not neutral_data.empty else 0
            
            result = f"""
            # Longitude Logistic Regression Results
            
            β1 (ONI coefficient): {beta_1:.4f}
            exp(β1) (Odds Ratio): {exp_beta_1:.4f}
            P-value: {p_value:.4f}
            
            Interpretation:
            - For each unit increase in ONI, the odds of a typhoon forming west of 140°E are {"increased" if exp_beta_1 > 1 else "decreased"} by a factor of {exp_beta_1:.2f}.
            - This effect is {"statistically significant" if p_value < 0.05 else "not statistically significant"} at the 0.05 level.
            
            Proportion of typhoons forming west of 140°E:
            - El Niño conditions: {el_nino_western:.2%}
            - La Niña conditions: {la_nina_western:.2%}
            - Neutral conditions: {neutral_western:.2%}
            """
        
        return result
    except Exception as e:
        return f"Error performing logistic regression: {str(e)}"

# Define Gradio interface
def create_interface():
    # Initialize data first
    initialize_data()
    
    # Define interface tabs
    with gr.Blocks(title="Typhoon Analysis Dashboard") as demo:
        gr.Markdown("# Typhoon Analysis Dashboard")
        
        with gr.Tab("Typhoon Tracks Analysis"):
            with gr.Row():
                with gr.Column():
                    start_year = gr.Number(value=2000, label="Start Year", minimum=1950, maximum=2024, step=1)
                    start_month = gr.Number(value=1, label="Start Month", minimum=1, maximum=12, step=1)
                with gr.Column():
                    end_year = gr.Number(value=2024, label="End Year", minimum=1950, maximum=2024, step=1)
                    end_month = gr.Number(value=6, label="End Month", minimum=1, maximum=12, step=1)
            
            enso_dropdown = gr.Dropdown(
                choices=["All Years", "El Niño Years", "La Niña Years", "Neutral Years"],
                value="All Years",
                label="ENSO Phase"
            )
            
            typhoon_search = gr.Textbox(label="Search Typhoon Name")
            
            analyze_button = gr.Button("Analyze Tracks")
            
            with gr.Row():
                tracks_plot = gr.Plot(label="Typhoon Tracks")
                stats_text = gr.Textbox(label="Statistics", lines=4)
            
            with gr.Row():
                wind_plot = gr.Plot(label="Wind Speed vs ONI")
                pressure_plot = gr.Plot(label="Pressure vs ONI")
            
            analyze_button.click(
                analyze_typhoon_tracks,
                inputs=[start_year, start_month, end_year, end_month, enso_dropdown, typhoon_search],
                outputs=[tracks_plot, wind_plot, pressure_plot, stats_text]
            )
        
        with gr.Tab("Clustering Analysis"):
            with gr.Row():
                with gr.Column():
                    cluster_start_year = gr.Number(value=2000, label="Start Year", minimum=1950, maximum=2024, step=1)
                    cluster_start_month = gr.Number(value=1, label="Start Month", minimum=1, maximum=12, step=1)
                with gr.Column():
                    cluster_end_year = gr.Number(value=2024, label="End Year", minimum=1950, maximum=2024, step=1)
                    cluster_end_month = gr.Number(value=6, label="End Month", minimum=1, maximum=12, step=1)
            
            with gr.Row():
                n_clusters = gr.Number(value=5, label="Number of Clusters", minimum=1, maximum=20, step=1)
                cluster_enso_dropdown = gr.Dropdown(
                    choices=["All Years", "El Niño Years", "La Niña Years", "Neutral Years"],
                    value="All Years",
                    label="ENSO Phase"
                )
            
            analysis_type = gr.Radio(
                choices=["Show Routes", "Show Clusters", "Fourier Series"],
                value="Show Clusters", 
                label="Analysis Type"
            )
            
            cluster_button = gr.Button("Run Cluster Analysis")
            
            cluster_plot = gr.Plot(label="Typhoon Routes Clustering")
            equation_text = gr.Textbox(label="Cluster Equations", lines=15)
            
            cluster_button.click(
                run_cluster_analysis,
                inputs=[
                    cluster_start_year, cluster_start_month, cluster_end_year, 
                    cluster_end_month, n_clusters, cluster_enso_dropdown, analysis_type
                ],
                outputs=[cluster_plot, equation_text]
            )
        
        with gr.Tab("Regression Analysis"):
            with gr.Row():
                with gr.Column():
                    reg_start_year = gr.Number(value=2000, label="Start Year", minimum=1950, maximum=2024, step=1)
                    reg_start_month = gr.Number(value=1, label="Start Month", minimum=1, maximum=12, step=1)
                with gr.Column():
                    reg_end_year = gr.Number(value=2024, label="End Year", minimum=1950, maximum=2024, step=1)
                    reg_end_month = gr.Number(value=6, label="End Month", minimum=1, maximum=12, step=1)
            
            regression_type = gr.Radio(
                choices=["Wind Speed", "Pressure", "Longitude"],
                value="Wind Speed", 
                label="Regression Type"
            )
            
            regression_button = gr.Button("Perform Logistic Regression")
            
            regression_results = gr.Textbox(label="Regression Results", lines=15)
            
            regression_button.click(
                perform_logistic_regression,
                inputs=[reg_start_year, reg_start_month, reg_end_year, reg_end_month, regression_type],
                outputs=regression_results
            )
        
        with gr.Tab("Typhoon Path Animation"):
            with gr.Row():
                year_dropdown = gr.Dropdown(
                    choices=[str(year) for year in range(1950, 2025)],
                    value="2024",
                    label="Year"
                )
                
                typhoon_dropdown = gr.Dropdown(
                    label="Typhoon",
                    interactive=True
                )
                
                standard_dropdown = gr.Dropdown(
                    choices=["atlantic", "taiwan"],
                    value="atlantic",
                    label="Classification Standard"
                )
            
            # Update typhoon dropdown when year changes
            year_dropdown.change(
                lambda year: (
                    [{"label": name, "value": id} for name, id in get_typhoons_for_year(year)],
                    get_typhoons_for_year(year)[0][1] if get_typhoons_for_year(year) else None
                ),
                inputs=year_dropdown,
                outputs=[typhoon_dropdown, typhoon_dropdown]
            )
            
            animation_button = gr.Button("Generate Animation")
            
            typhoon_animation = gr.Plot(label="Typhoon Path Animation")
            
            animation_button.click(
                create_typhoon_path_animation,
                inputs=[year_dropdown, typhoon_dropdown, standard_dropdown],
                outputs=typhoon_animation
            )
    
    return demo

# Run the app
if __name__ == "__main__":
    # Schedule background tasks
    schedule.every().day.at("01:00").do(update_ibtracs_data)
    schedule.every().day.at("00:00").do(lambda: update_oni_data() if should_update_oni() else None)
    scheduler_thread = threading.Thread(target=run_schedule)
    scheduler_thread.daemon = True
    scheduler_thread.start()
    
    # Create and launch the Gradio interface
    demo = create_interface()
    demo.launch(server_name="127.0.0.1", server_port=7860)