metro_simulator.py

import math

freq_peak = 4
freq_offpeak = 8


fares = [
    (2, 11),
    (5, 21),
    (12, 32),
    (21, 43),
    (32, 54),
    (float('inf'), 64)
]

METRO_LINES = {}
TRAVEL_TIMES = {}
INTERCHANGES = {}

# Time functions
def to_minutes(time_str):
    h, m = map(int, time_str.split(":"))
    return h * 60 + m

def minutes_to_str(mins):
    h = mins // 60
    m = mins % 60
    return f"{h:02d}:{m:02d}"

op_start_min = to_minutes("06:00")
op_end_min   = to_minutes("23:00")

peak1_start = to_minutes("08:00")
peak1_end   = to_minutes("11:00")
peak2_start = to_minutes("17:00")
peak2_end   = to_minutes("20:00") 

def is_working_time(minute):
    return op_start_min <= minute <= op_end_min
def get_frequency(minute):
    if (peak1_start < minute < peak1_end) or (peak2_start < minute < peak2_end):
        return freq_peak
    return freq_offpeak

# Load data from file
def load_data(file):

    global METRO_LINES, TRAVEL_TIMES, INTERCHANGES

    try:
        with open(file, 'r') as f:
            for row in f:
                row = row.strip()
                if not row or row.startswith('#'):
                    continue

                parts = [p.strip() for p in row.split(',')]

                # skip header
                if parts[0].lower() == 'line':
                    continue

                if len(parts) != 5:
                    continue

                line_name, station, next_station, time_str, _flag = parts

                # Create line entry
                if line_name not in METRO_LINES:
                    METRO_LINES[line_name] = []

                # Add station
                if station not in METRO_LINES[line_name]:
                    METRO_LINES[line_name].append(station)

                # Add next station
                if next_station and next_station not in METRO_LINES[line_name]:
                    METRO_LINES[line_name].append(next_station)

                # Add travel times both ways
                try:
                    t = int(time_str)
                    TRAVEL_TIMES[(station, next_station)] = t
                    TRAVEL_TIMES[(next_station, station)] = t
                except:
                    pass

    except FileNotFoundError:
        print("File not found.")
        return False

    station_lines = {}

    for line, stations in METRO_LINES.items():
        for s in stations:
            station_lines.setdefault(s, set()).add(line)

    # A station is an interchange if it appears in 2+ lines
    INTERCHANGES = {s: lines for s, lines in station_lines.items() if len(lines) >= 2}


    globals()['INTERCHANGES'] = INTERCHANGES

    return True


load_data("metro_data.txt")

# getting start and end time offset

def get_offset(line, terminal, station):

    stations = METRO_LINES[line]

    if not stations:
        return None
    

    #getting offset from first station
    if terminal == stations[0]:
        offset = 0
        i_station = 0

        while i_station < len(stations):
            if stations[i_station] == station:
                return offset
            if i_station + 1 < len(stations):
                offset += TRAVEL_TIMES.get((stations[i_station], stations[i_station + 1]), 0)
            i_station += 1
        return offset
    
    #getting offset if its the last station

    elif terminal == stations[-1]:
        offset = 0
        i_station = len(stations) - 1

        while i_station >= 0:
            if stations[i_station] == station:
                return offset
            if i_station - 1 >= 0:
                offset += TRAVEL_TIMES.get((stations[i_station], stations[i_station - 1]), 0)
            i_station -= 1
        return offset
    else:
        return None
    
#getting arrival time of next metro from both directions

def get_next_metro(line, check_time, station):
    for s in METRO_LINES[line]:
        if station == s:
            offset_start = get_offset(line, METRO_LINES[line][0], station)
            offset_end = get_offset(line, METRO_LINES[line][-1], station)

            first_arival_start = op_start_min + offset_start
            first_arival_end = op_start_min + offset_end

            last_arival_start = op_end_min + offset_start
            last_arival_end = op_end_min + offset_end

            check_time = to_minutes(check_time)

            next_time_start, next_time_end = None, None

            if check_time <= first_arival_start:
                next_time_start = first_arival_start
            elif check_time <= last_arival_start:
                k = math.ceil((check_time - first_arival_start) / get_frequency(check_time))
                next_time = first_arival_start + k * get_frequency(check_time)
                next_time_start = next_time
            elif check_time > last_arival_start:
                next_time_start = "No service."

            if check_time <= first_arival_end:
                next_time_end = first_arival_end
            elif check_time <= last_arival_end:
                k = math.ceil((check_time - first_arival_end) / get_frequency(check_time))
                next_time = first_arival_end + k * get_frequency(check_time)
                next_time_end = next_time
            elif check_time > last_arival_end:
                next_time_end = "No service."

            return (line, next_time_start, next_time_end)
    return None

# print(get_next_metro("Yellow", "10:13", "Rajiv Chowk"))
# print(get_next_metro("Blue", "10:13", "Rajiv Chowk"))
# print(get_next_metro("Blue", "23:50", "Dwarka Sector 21"))


#get route on same line

def get_route_same_line(stations, source, destination):
    source_index = stations.index(source)
    destination_index = stations.index(destination)

    if source_index < destination_index:
        return stations[source_index:destination_index + 1]
    else:
        return stations[destination_index:source_index + 1][::-1]
    
# print(get_route_same_line(METRO_LINES["Blue"], "Rajiv Chowk", "Noida Sector 62"))

def get_route(source, destination, transfers=0, visited=set()):

    all_routes = []

    if transfers > 2:
        return None
    visited.add(source)

    for line in METRO_LINES:
        stations = METRO_LINES[line]
        if source in stations and destination in stations:
            path = get_route_same_line(stations, source, destination)
            t=0
            for i in range(len(path)-1):
                t+= TRAVEL_TIMES.get((path[i], path[i+1]), 0)
            all_routes.append([(line, path, t)])
    
    for line in METRO_LINES:
        stations = METRO_LINES[line]
        if source not in stations:
            continue

        for interchange in INTERCHANGES.keys():
            if interchange not in stations:
                continue
            if interchange in visited:
                continue
            
            base_path = get_route_same_line(stations, source, interchange)

            interchange_path = get_route(interchange, destination, transfers+1, visited.copy())

            t=0
            for i in range(len(base_path)-1):
                t+= TRAVEL_TIMES.get((base_path[i], base_path[i+1]), 0)

            if interchange_path != None:
                route = [(line, base_path, t)] + interchange_path
                all_routes.append(route)
    if all_routes:
        fastest_time = sum([t for line, stations, t in all_routes[0]])
        fastest_route = all_routes[0]
        for route in all_routes:
            if sum([t for line, stations, t in route]) < fastest_time:
                fastest_time = sum([t for line, stations, t in route])
                fastest_route = route
        return fastest_route
    else:
        return None

# print(get_route("Kashmere Gate", "Botanical Garden"))


#finding direction to manage which side time to take
def get_direction(line, source, destination, time):
    stations = METRO_LINES[line]
    source_id = stations.index(source)
    destination_id = stations.index(destination)

    metro_times = get_next_metro(line, time, source)
    if not metro_times:
        return None

    if source_id < destination_id:
        direction = METRO_LINES[line][-1]
    else:
        direction = METRO_LINES[line][0]

    return direction



def next_metro(line, station, current_time):
    result = get_next_metro(line, current_time, station)
    if result:
        line, next_time_start, next_time_end = result
        ts1 = next_time_start
        ts2 = ts1+get_frequency(ts1)
        ts3 = ts2+get_frequency(ts2)
        print(f"Next metro towards {METRO_LINES[line][-1]} at {minutes_to_str(ts1)}")
        print(f"Subsequent metro towards {METRO_LINES[line][-1]} at {minutes_to_str(ts2)}, {minutes_to_str(ts3)}...")
        te1 = next_time_end
        te2 = te1+get_frequency(te1)
        te3 = te2+get_frequency(te2)
        print(f"Next metro towards {METRO_LINES[line][0]} at {minutes_to_str(te1)}")
        print(f"Subsequent metro towards {METRO_LINES[line][0]} at {minutes_to_str(te2)}, {minutes_to_str(te3)}...")

# next_metro("Yellow", "Rajiv Chowk", "10:13")
# print(get_route("Kashmere Gate", "Botanical Garden"))


def journey(source, destination, tot):
    interchange_delay = 3
    print("Journey Plan:")
    route = get_route(source, destination)
    print(f"Start at {source} ({route[0][0]} line)")
    if not route:
        print("No route found.")
        return
    line, arival_time_start, arival_time_end = get_next_metro(route[0][0], tot, source)
    towards = get_direction(route[0][0], source, route[0][1][-1], tot)
    if towards == METRO_LINES[route[0][0]][-1]:
        print(f"Next metro at {minutes_to_str(arival_time_start)} towards {towards}")
        waiting_time = arival_time_start - to_minutes(tot)
    else:
        print(f"Next metro at {minutes_to_str(arival_time_end)} towards {towards}")
        waiting_time = arival_time_end - to_minutes(tot)
    t = to_minutes(tot) + route[0][2]+waiting_time
    print(f"Arrive at {route[0][1][-1]} at {minutes_to_str(t)} minutes.")

    i = 1
    while i < len(route):
        line, stations, travel_time = route[i]
        print(f"Transfer to {line} line.")
        t += interchange_delay
        arival_time_start, arival_time_end = get_next_metro(line, minutes_to_str(t), stations[0])[1:]
        towards = get_direction(line, stations[0], stations[-1], minutes_to_str(t))
        if towards == METRO_LINES[line][-1]:
            print(f"Next metro at {minutes_to_str(arival_time_start)} towards {towards}")
            waiting_time = arival_time_start - t
        else:
            print(f"Next metro at {minutes_to_str(arival_time_end)} towards {towards}")
            waiting_time = arival_time_end - t
        t += travel_time + waiting_time
        print(f"Arrive at {stations[-1]} at {minutes_to_str(t)} minutes.")
        i += 1
    travel_time_total = t - to_minutes(tot)
    print(f"Total travel time: {minutes_to_str(travel_time_total)} minutes.")

    station_order = set()

    for i in range(len(route)):
        line, stations, travel_time = route[i]
        station_order.update(stations)
    num_stations = len(station_order)-1
    fare = 0
    for n_station, f in fares:
        if num_stations <= n_station:
            fare = f
            break
    print(f"Total stations traveled: {num_stations}")
    print(f"Total fare: ₹{fare}")

# journey("Dwarka", "Botanical Garden", "10:12")

def check_station_exists(station_name):
    for stations in METRO_LINES.values():
        if station_name in stations:
            return True
    return False


def main():
    while True:
        print("1. Get next metro timings")
        print("2. Plan a journey")
        choice = input("Enter your choice (1/2): ")

        #checking valid names here only so that we don't get None ValueError in the defined functions

        if choice == '1':
            line = input("Enter metro line: ")
            if line not in METRO_LINES:
                print("Invalid line name, please try again.")
                continue
            station = input("Enter station name: ")
            if not check_station_exists(station):
                print("invalid station, please try again.")
                continue
            current_time = input("Enter current time (HH:MM): ")
            next_metro(line, station, current_time)
            break
        elif choice == '2':
            source = input("Enter source station: ")
            if not check_station_exists(source):
                print("invalid station, please try again.")
                continue
            destination = input("Enter destination station: ")
            if not check_station_exists(destination):
                print("Invalid station, please try again.")
                continue
            start_time = input("Enter start time (HH:MM): ")
            journey(source, destination, start_time)
            break
        else:
            print("Invalid choice. Please try again.")

main()