Capstone: Ride-Sharing App

class Location {
    private final double latitude, longitude;

    Location(double latitude, double longitude) { this.latitude = latitude; this.longitude = longitude; }

    double calculateDistanceFrom(Location other) { // was a static helper on the service -- now a method ON the thing it's about
        double dx = this.latitude - other.latitude;
        double dy = this.longitude - other.longitude;
        return Math.sqrt(dx * dx + dy * dy);
    }
}

abstract class User {
    protected String name;
    protected String email;
    protected Location location; // protected -- Driver and Passenger need direct access

    User(String name, String email, Location location) {
        this.name = name; this.email = email; this.location = location;
    }

    Location getLocation() { return location; }
    void setLocation(Location location) { this.location = location; }

    abstract void notify(String message); // every user must be notifiable, but HOW is left to each subclass
}

class Driver extends User {
    private final Vehicle vehicle; // the ONE thing a Driver has that a Passenger doesn't

    Driver(String name, String email, Location location, Vehicle vehicle) {
        super(name, email, location);
        this.vehicle = vehicle;
    }

    Vehicle getVehicle() { return vehicle; }

    public void notify(String message) {
        System.out.println("[Driver] " + name + ": " + message);
    }
}

class Passenger extends User {
    Passenger(String name, String email, Location location) { super(name, email, location); }

    public void notify(String message) {
        System.out.println("[Passenger] " + name + ": " + message);
    }
}

abstract class Vehicle {
    protected String numberPlate;

    Vehicle(String numberPlate) { this.numberPlate = numberPlate; }

    abstract double getFarePerKilometer(); // the type string is GONE -- this is what replaces it
}

class Car extends Vehicle {
    Car(String numberPlate) { super(numberPlate); }
    double getFarePerKilometer() { return 20; }
}

class Bike extends Vehicle {
    Bike(String numberPlate) { super(numberPlate); }
    double getFarePerKilometer() { return 10; }
}

interface FareStrategy {
    double calculateFare(Vehicle vehicle, double distance);
}

class StandardFareStrategy implements FareStrategy {
    public double calculateFare(Vehicle vehicle, double distance) {
        return vehicle.getFarePerKilometer() * distance; // no if/else on vehicle type -- the vehicle answers for itself
    }
}

class SharedFareStrategy implements FareStrategy {
    public double calculateFare(Vehicle vehicle, double distance) {
        return vehicle.getFarePerKilometer() * distance * 0.5; // 50% off, for a shared ride
    }
}

class LuxuryFareStrategy implements FareStrategy {
    public double calculateFare(Vehicle vehicle, double distance) {
        return vehicle.getFarePerKilometer() * distance * 1.5; // 50% surcharge
    }
}

enum RideStatus { SCHEDULED, ONGOING, COMPLETED }

class Ride {
    private final Passenger passenger;
    private final Driver driver;
    private final double distance;
    private final FareStrategy fareStrategy;
    private double fare;
    private RideStatus status;

    Ride(Passenger passenger, Driver driver, double distance, FareStrategy fareStrategy) {
        this.passenger = passenger; this.driver = driver;
        this.distance = distance; this.fareStrategy = fareStrategy;
        this.status = RideStatus.SCHEDULED; // every ride starts here
    }

    void calculateFare() {
        this.fare = fareStrategy.calculateFare(driver.getVehicle(), distance); // polymorphic: which strategy, which vehicle, both resolved at runtime
    }

    double getFare() { return fare; }

    void updateStatus(RideStatus status) {
        this.status = status;
        notifyUsers(status); // every status change reaches BOTH watchers, automatically
    }

    private void notifyUsers(RideStatus status) {
        passenger.notify("Your ride is " + status); // this is the Observer pattern, even though neither class is named "Observer"
        driver.notify("Your ride is " + status);
    }
}

class RideMatchingService {
    private final List<Driver> availableDrivers = new ArrayList<>();

    void addDriver(Driver driver) { availableDrivers.add(driver); }

    void requestRide(Passenger passenger, double distance, FareStrategy fareStrategy) {
        if (availableDrivers.isEmpty()) {
            passenger.notify("No drivers are available right now"); // the earlier bug's fix starts here
            return;
        }

        Driver nearestDriver = findNearestDriver(passenger.getLocation());
        availableDrivers.remove(nearestDriver); // FIXES the earlier bug -- a booked driver is no longer available

        Ride ride = new Ride(passenger, nearestDriver, distance, fareStrategy);
        ride.calculateFare();

        passenger.notify("Ride scheduled with fare \u20b9" + ride.getFare());
        nearestDriver.notify("New ride request for \u20b9" + ride.getFare());

        ride.updateStatus(RideStatus.ONGOING);   // simulating time passing
        ride.updateStatus(RideStatus.COMPLETED);

        availableDrivers.add(nearestDriver);     // the driver becomes available again once the ride finishes
    }

    private Driver findNearestDriver(Location passengerLocation) {
        Driver nearest = null;
        double minDistance = Double.MAX_VALUE;
        for (Driver driver : availableDrivers) {
            double d = driver.getLocation().calculateDistanceFrom(passengerLocation); // called ON Location now, not a static helper
            if (d < minDistance) { minDistance = d; nearest = driver; }
        }
        return nearest;
    }
}

public class Client {
    public static void main(String[] args) {
        Location locationA = new Location(12.93, 77.61);
        Location locationB = new Location(12.97, 77.59);
        Location passengerLocation = new Location(12.96, 77.60);

        Driver raj   = new Driver("Raj", "raj@example.com", locationA, new Car("KA-01-1234"));
        Driver alice = new Driver("Alice", "alice@example.com", locationB, new Bike("KA-05-9876"));
        Passenger priya = new Passenger("Priya", "priya@example.com", passengerLocation);

        RideMatchingService matchingService = new RideMatchingService();

        matchingService.requestRide(priya, 10, new StandardFareStrategy());
        // "[Passenger] Priya: No drivers are available right now" -- no drivers added yet

        matchingService.addDriver(raj);
        matchingService.addDriver(alice);

        matchingService.requestRide(priya, 10, new StandardFareStrategy());
    }
}