Define Class Members (write code)

Attributes: For each class, define the attributes (data) it will hold...
Methods: Define the methods (functions) that operate on the attributes. Ensure they align with the object's responsibilities and adhere to the principle of encapsulation.
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

enum ParkingType { COMPACT, LARGE, HANDICAPPED }

class ParkingLot {
    private final String id;
    private final int floors;
    private final ParkingSpotManager spotManager;
    private final PaymentService paymentService;

    public ParkingLot(String id, int floors, PaymentHandler paymentHandler) {
        this.id = id;
        this.floors = floors;
        this.spotManager = new ParkingSpotManager();
        this.paymentService = new PaymentService(paymentHandler);
    }

    public ParkingTicket assignSpot(User user, ParkingType type) {
        ParkingSpot spot = spotManager.getAvailableSpotByType(type);
        if (spot == null) throw new RuntimeException("No spot available");
        spot.setAvailable(false);

        ParkingTicket ticket = new ParkingTicket(UUID.randomUUID().toString(), user, spot);
        user.addTicket(ticket);
        return ticket;
    }

    public void freeSpot(ParkingTicket ticket) {
        ParkingSpot spot = ticket.getSpot();
        spot.setAvailable(true);
        paymentService.processPayment(ticket);
    }

    public void addSpot(Floor floor, double rate, ParkingType type) {
        spotManager.addParkingSpot(floor, rate, type);
    }
}

// ParkingSpotManager with concurrency-safe structures
class ParkingSpotManager {
    private final Map<String, ParkingSpot> spots = new ConcurrentHashMap<>();

    public void addParkingSpot(Floor floor, double rate, ParkingType type) {
        ParkingSpot spot = new ParkingSpot(UUID.randomUUID().toString(), floor, type, rate);
        spots.put(spot.getId(), spot);
    }

    public ParkingSpot getAvailableSpotByType(ParkingType type) {
        return spots.values().stream()
                .filter(s -> s.isAvailable() && s.getType() == type)
                .findFirst().orElse(null);
    }

    public List<ParkingSpot> getAvailableSpots() {
        List<ParkingSpot> available = new ArrayList<>();
        for (ParkingSpot s : spots.values()) {
            if (s.isAvailable()) available.add(s);
        }
        return available;
    }
}

class PaymentService {
    private final PaymentHandler handler;

    public PaymentService(PaymentHandler handler) {
        this.handler = handler;
    }

    public void processPayment(ParkingTicket ticket) {
        if (!handler.processPayment(ticket)) {
            throw new RuntimeException("Payment failed");
        }
    }
}

interface PaymentHandler {
    boolean processPayment(ParkingTicket ticket);
}

class StripePaymentHandler implements PaymentHandler {
    @Override
    public boolean processPayment(ParkingTicket ticket) {
        double amount = ticket.calculateTotalFee();
        System.out.println("Stripe payment processed: $" + amount);
        return true;
    }
}

class User {
    private final String id;
    private final String name;
    private final List<ParkingTicket> activeTickets = Collections.synchronizedList(new ArrayList<>());

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

    public void addTicket(ParkingTicket ticket) {
        activeTickets.add(ticket);
    }
}

class Floor {
    private final String id;
    private final int floorNo;

    public Floor(String id, int floorNo) {
        this.id = id;
        this.floorNo = floorNo;
    }

    public int getFloorNo() { return floorNo; }
}

class ParkingSpot {
    private final String id;
    private final Floor floor;
    private final ParkingType type;
    private final double rate;
    private volatile boolean isAvailable;
    private final ReentrantLock lock = new ReentrantLock();

    public ParkingSpot(String id, Floor floor, ParkingType type, double rate) {
        this.id = id;
        this.floor = floor;
        this.type = type;
        this.rate = rate;
        this.isAvailable = true;
    }

    public String getId() { return id; }
    public ParkingType getType() { return type; }
    public boolean isAvailable() { return isAvailable; }

    public void setAvailable(boolean available) {
        lock.lock();
        try {
            this.isAvailable = available;
        } finally {
            lock.unlock();
        }
    }

    public double getRate() { return rate; }
}

class ParkingTicket {
    private final String id;
    private final LocalDateTime startTime;
    private final User user;
    private final ParkingSpot spot;
    private LocalDateTime endTime;

    public ParkingTicket(String id, User user, ParkingSpot spot) {
        this.id = id;
        this.startTime = LocalDateTime.now();
        this.user = user;
        this.spot = spot;
    }

    public void endParking() { this.endTime = LocalDateTime.now(); }
    public ParkingSpot getSpot() { return spot; }

    public double calculateTotalFee() {
        endParking();
        Duration duration = Duration.between(startTime, endTime);
        long hours = duration.toHours();
        if (hours == 0) hours = 1; // Minimum 1 hour
        return hours * spot.getRate();
    }
}

public class Main {
    public static void main(String[] args) {
        // Setup
        PaymentHandler paymentHandler = new StripePaymentHandler();
        ParkingLot lot = new ParkingLot("Lot1", 3, paymentHandler);
        Floor floor1 = new Floor("F1", 1);
        lot.addSpot(floor1, 10.0, ParkingType.COMPACT);

        // Use case
        User user = new User("U1", "John Doe");
        ParkingTicket ticket = lot.assignSpot(user, ParkingType.COMPACT);
        System.out.println("Spot assigned: " + ticket.getSpot().getId());

        // Release the spot and pay
        lot.freeSpot(ticket);
    }
}
Submissions

Displaying Solutions with Scores Ranging from 1 to 10
