import pandas as pd
from math import radians, sin, cos, sqrt, asin
import time

### Modular Flight Calculation Functions ###

def get_aircraft_details(aircraft_type):
    """
    Fetch aircraft details based on the given aircraft type.
    """
    csv_file = 'aircraft.csv'
    df = pd.read_csv(csv_file)
    if aircraft_type not in df['Aircraft'].values:
        return f"Aircraft type '{aircraft_type}' not found in the dataset."
    
    aircraft_details = df[df['Aircraft'] == aircraft_type][[
        'Range_km', 'Fuel_Consumption_kg/hr', 'Cruising Speed (kts)', 
        'Speed_kmh', 'MaxFlightTime_hr', 'Max_Fuel_Capacity_kg']]
    
    return aircraft_details.to_dict(orient='records')[0]


def get_airport_lat_long(identifiers):
    """
    Get latitude and longitude for a list of airport identifiers (IATA codes).
    """
    csv_file = 'airport.csv' 
       
    start_time = time.time()
    df = pd.read_csv(csv_file)
    read_time = time.time() - start_time
    print(f"CSV file read in {read_time:.4f} seconds")
    
    df_filtered = df[df['Airport_Name'].isin(identifiers) | df['IATA'].isin(identifiers)]
    lat_long_dict = {row['IATA']: (row['Lat'], row['Long']) for _, row in df_filtered.iterrows()}
    return lat_long_dict


def haversine_distance(lat1, lon1, lat2, lon2):
    """
    Calculate the Haversine distance between two points on Earth (in kilometers).
    """
    R = 6371.0  # Earth radius in kilometers
    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
    dlat, dlon = lat2 - lat1, lon2 - lon1
    a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
    return round(R * 2 * asin(sqrt(a)), 2)


def calculate_distances(airport_identifiers):
    """
    Calculate the distance between each pair of airports.
    """
    lat_long_dict = get_airport_lat_long(airport_identifiers)
    distances = {}
    for i in range(len(airport_identifiers)):
        for j in range(i + 1, len(airport_identifiers)):
            airport1, airport2 = airport_identifiers[i], airport_identifiers[j]
            lat1, lon1 = lat_long_dict[airport1]
            lat2, lon2 = lat_long_dict[airport2]
            distances[(airport1, airport2)] = haversine_distance(lat1, lon1, lat2, lon2)
    return distances


def calculate_fuel_and_time_for_segment(segment_distance, aircraft_specs):
    """
    Calculate the fuel and time required for a single flight segment.
    """
    cruising_speed = aircraft_specs['Speed_kmh']
    fuel_burn_rate = aircraft_specs['Fuel_Consumption_kg/hr']
    max_fuel_capacity = aircraft_specs['Max_Fuel_Capacity_kg']
    reserve_fuel_percentage = 0.05  # 5% reserve fuel

    climb_speed, descent_speed = 300, 350
    climb_time, descent_time = 15 / 60, 10 / 60  # in hours
    climb_distance = climb_speed * climb_time
    descent_distance = descent_speed * descent_time

    # Calculate cruise distance
    cruise_distance = segment_distance - (climb_distance + descent_distance)
    cruise_distance = max(0, cruise_distance)  # Ensure cruise distance is not negative

    # Calculate flight time for each phase
    cruise_time = cruise_distance / cruising_speed
    total_flight_time = climb_time + cruise_time + descent_time

    # Calculate fuel required
    fuel_required = total_flight_time * fuel_burn_rate
    reserve_fuel = reserve_fuel_percentage * max_fuel_capacity
    total_fuel_with_reserve = fuel_required + reserve_fuel

    return total_fuel_with_reserve, total_flight_time