Design Uber (LLD)

from abc import ABC, abstractmethod

class FarePolicy(ABC):
    @abstractmethod
    def apply(self, trip, fare: float) -> float: 
        pass

class BaseFare(FarePolicy):           # flat amount by city/vehicle class
    def __init__(self, base_rates: dict):
        self.base_rates = base_rates
        
    def apply(self, trip, fare): 
        return fare + self.base_rates.get(trip.vehicle_class, 5.0)

class DistanceTime(FarePolicy):       # per-km + per-minute
    def __init__(self, per_km: float, per_min: float):
        self.per_km = per_km
        self.per_min = per_min
        
    def apply(self, trip, fare):
        return fare + trip.km * self.per_km + trip.minutes * self.per_min

class SurgeMultiplier(FarePolicy):    # multiplies everything BEFORE it
    def apply(self, trip, fare): 
        return fare * trip.surge_at_request

class PromoDiscount(FarePolicy):      # subtracts AFTER surge, floor at minimum
    def __init__(self, min_fare: float):
        self.minimum_fare = min_fare
        
    def apply(self, trip, fare):
        discount = 2.0  # mock promo
        return max(fare - discount, self.minimum_fare)

import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

enum TripState { REQUESTED, MATCHING, ASSIGNED, ARRIVING, IN_PROGRESS, COMPLETED, CANCELLED }
enum DriverStatus { OFFLINE, AVAILABLE, OFFERED, ON_TRIP }

class User {
    String id;
    String name;
    User(String id, String name) { this.id = id; this.name = name; }
}

class Driver {
    String id;
    DriverStatus status = DriverStatus.AVAILABLE;
    final ReentrantLock lock = new ReentrantLock();
    Driver(String id) { this.id = id; }
}

interface FarePolicy {
    long apply(double km, int minutes, double surge, long runningFare);
}

class BaseFarePolicy implements FarePolicy {
    public long apply(double km, int minutes, double surge, long runningFare) {
        return runningFare + 5000; // Flat 50.00 base fare in cents
    }
}

class DistanceTimePolicy implements FarePolicy {
    public long apply(double km, int minutes, double surge, long runningFare) {
        return runningFare + (long)(km * 150) + (long)(minutes * 50); // 1.50/km, 0.50/min
    }
}

class SurgePolicy implements FarePolicy {
    public long apply(double km, int minutes, double surge, long runningFare) {
        return (long)(runningFare * surge);
    }
}

class FareCalculator {
    private final List<FarePolicy> policies;
    FareCalculator(List<FarePolicy> policies) { this.policies = policies; }
    
    public long calculateFare(double km, int minutes, double surge) {
        long fare = 0;
        for (FarePolicy policy : policies) {
            fare = policy.apply(km, minutes, surge, fare);
        }
        return fare;
    }
}

class Trip {
    String tripId;
    User rider;
    Driver driver;
    TripState state = TripState.REQUESTED;
    double km;
    int minutes;
    double surgeAtRequest;
    long finalFareCents;
    final ReentrantLock lock = new ReentrantLock();

    Trip(String id, User rider, double surge) {
        this.tripId = id;
        this.rider = rider;
        this.surgeAtRequest = surge;
    }

    public void assignDriver(Driver d) {
        lock.lock();
        try {
            d.lock.lock();
            try {
                if (d.status != DriverStatus.AVAILABLE) {
                    throw new IllegalStateException("Driver is busy");
                }
                this.driver = d;
                this.state = TripState.ASSIGNED;
                d.status = DriverStatus.ON_TRIP;
            } finally {
                d.lock.unlock();
            }
        } finally {
            lock.unlock();
        }
    }
}

#include <string>
#include <vector>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <algorithm>
#include <stdexcept>

enum class TripState { REQUESTED, MATCHING, ASSIGNED, ARRIVING, IN_PROGRESS, COMPLETED, CANCELLED };
enum class DriverStatus { OFFLINE, AVAILABLE, OFFERED, ON_TRIP };

class User {
public:
    std::string id;
    std::string name;
    User(std::string i, std::string n) : id(i), name(n) {}
};

class Driver {
public:
    std::string id;
    DriverStatus status = DriverStatus::AVAILABLE;
    std::mutex mtx;
    Driver(std::string i) : id(i) {}
};

class FarePolicy {
public:
    virtual ~FarePolicy() = default;
    virtual long long apply(double km, int minutes, double surge, long long runningFare) = 0;
};

class BaseFarePolicy : public FarePolicy {
public:
    long long apply(double km, int minutes, double surge, long long runningFare) override {
        return runningFare + 5000; // Base flat 50.00
    }
};

class DistanceTimePolicy : public FarePolicy {
public:
    long long apply(double km, int minutes, double surge, long long runningFare) override {
        return runningFare + static_cast<long long>(km * 150) + static_cast<long long>(minutes * 50);
    }
};

class SurgePolicy : public FarePolicy {
public:
    long long apply(double km, int minutes, double surge, long long runningFare) override {
        return static_cast<long long>(runningFare * surge);
    }
};

class FareCalculator {
private:
    std::vector<std::shared_ptr<FarePolicy>> policies;
public:
    FareCalculator(const std::vector<std::shared_ptr<FarePolicy>>& p) : policies(p) {}
    
    long long calculateFare(double km, int minutes, double surge) {
        long long fare = 0;
        for (const auto& policy : policies) {
            fare = policy->apply(km, minutes, surge, fare);
        }
        return fare;
    }
};

class Trip {
public:
    std::string tripId;
    std::shared_ptr<User> rider;
    std::shared_ptr<Driver> driver;
    TripState state = TripState::REQUESTED;
    double km = 0.0;
    int minutes = 0;
    double surgeAtRequest = 1.0;
    long long finalFareCents = 0;
    std::mutex mtx;

    Trip(std::string id, std::shared_ptr<User> r, double surge) 
        : tripId(id), rider(r), surgeAtRequest(surge) {}

    void assignDriver(std::shared_ptr<Driver> d) {
        std::lock_guard<std::mutex> lockTrip(mtx);
        std::lock_guard<std::mutex> lockDriver(d->mtx);

        if (d->status != DriverStatus::AVAILABLE) {
            throw std::runtime_error("Driver is busy");
        }
        driver = d;
        state = TripState::ASSIGNED;
        d->status = DriverStatus::ON_TRIP;
    }
};