Topmate is a platform connecting creators with their audience through paid sessions, content, and community features. Think Calendly + Patreon + Cameo.

Features Required

1. User Management

User registration with different types (Creator, Consumer, Admin)
User profiles (with basic info, and for creators, a CreatorProfile)

2. Session Management

Session creation by creators (with title, description, pricing, time slots)
Session status (DRAFT, PUBLISHED, etc.)
Time slot management (adding time slots, checking overlaps)

3. Booking System

Booking a session by a consumer
Booking status (PENDING, CONFIRMED, etc.)
Cancellation of bookings (with reasons and by whom)

4. Payment & Pricing

Pricing strategies (Fixed, Tiered)
Payment gateway integration (Stripe, Razorpay)
Platform commission calculation

5. Notifications

Notification system (Email, SMS, Push)
Event-driven notifications

9. Search & Query

Methods to search sessions and get bookings for a user or creator

10. Admin Features

Platform revenue calculation

Design Patterns Used

1. Builder Pattern

Reason: Complex object creation (Session, UserProfile, Payment) with many optional parameters
Benefit: Clean API, immutability, flexible object construction

2. Factory Pattern

Reason: Multiple notification types, payment gateways, user roles
Benefit: Encapsulates creation logic, easy to extend

3. Strategy Pattern

Reason: Multiple payment methods, pricing strategies, commission calculations
Benefit: Swappable algorithms, Open-Closed Principle

4. Observer Pattern

Reason: Real-time notifications, event-driven updates
Benefit: Loose coupling between components

5. Proxy Pattern

Reason: Caching for frequently accessed data, lazy loading
Benefit: Performance optimization, transparent to clients

6. Singleton Pattern

Reason: Session manager, notification service, rate limiter
Benefit: Single instance for critical services

7. Repository Pattern

Reason: Data access abstraction for different storage types
Benefit: Separation of concerns, testability

Java Implementation

// ==================== ENUMS & CONSTANTS ====================
enum SessionStatus {
    DRAFT, PUBLISHED, BOOKED, COMPLETED, CANCELLED, RESCHEDULED
}

enum BookingStatus {
    PENDING, CONFIRMED, CANCELLED_BY_CREATOR, CANCELLED_BY_USER, COMPLETED
}

enum PaymentStatus {
    PENDING, PROCESSING, COMPLETED, FAILED, REFUNDED
}

enum UserType {
    CREATOR, CONSUMER, ADMIN
}

enum NotificationType {
    EMAIL, SMS, PUSH, IN_APP
}

enum Currency {
    USD, EUR, GBP, INR
}

// ==================== BUILDER PATTERN: Complex Objects ====================
class TimeSlot {
    private Instant startTime;
    private Instant endTime;
    private Duration duration;
    private boolean isBooked;

    // Builder for TimeSlot
    public static class Builder {
        private Instant startTime;
        private Duration duration;

        public Builder startTime(Instant startTime) {
            this.startTime = startTime;
            return this;
        }

        public Builder duration(Duration duration) {
            this.duration = duration;
            return this;
        }

        public TimeSlot build() {
            return new TimeSlot(this);
        }
    }

    private TimeSlot(Builder builder) {
        this.startTime = builder.startTime;
        this.duration = builder.duration;
        this.endTime = startTime.plus(duration);
        this.isBooked = false;
    }

    // Getters
    public boolean overlaps(TimeSlot other) {
        return !(this.endTime.isBefore(other.startTime) || 
                this.startTime.isAfter(other.endTime));
    }
}

// ==================== USER MANAGEMENT ====================
class User {
    private String userId;
    private String email;
    private String displayName;
    private UserType userType;
    private String profilePictureUrl;
    private Instant createdAt;
    private boolean isVerified;
    private Map<String, String> metadata;

    // Fluent Builder
    public static class Builder {
        private String userId;
        private String email;
        private String displayName;
        private UserType userType = UserType.CONSUMER;

        public Builder userId(String userId) {
            this.userId = userId;
            return this;
        }

        public Builder email(String email) {
            this.email = email;
            return this;
        }

        public Builder displayName(String displayName) {
            this.displayName = displayName;
            return this;
        }

        public Builder userType(UserType userType) {
            this.userType = userType;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }

    private User(Builder builder) {
        this.userId = builder.userId;
        this.email = builder.email;
        this.displayName = builder.displayName;
        this.userType = builder.userType;
        this.createdAt = Instant.now();
        this.metadata = new HashMap<>();
    }

    public boolean isCreator() {
        return userType == UserType.CREATOR;
    }
}

class CreatorProfile {
    private String creatorId;
    private String bio;
    private String expertise;
    private double rating;
    private int totalSessions;
    private List<String> socialLinks;
    private Map<String, Object> stats;
    private PricingStrategy pricingStrategy;

    public CreatorProfile(String creatorId) {
        this.creatorId = creatorId;
        this.rating = 5.0;
        this.totalSessions = 0;
        this.socialLinks = new ArrayList<>();
        this.stats = new HashMap<>();
        this.pricingStrategy = new FixedPricingStrategy();
    }

    public void updateRating(int newRating) {
        // Weighted average calculation
        double totalRatings = this.rating * this.totalSessions;
        this.totalSessions++;
        this.rating = (totalRatings + newRating) / this.totalSessions;
    }
}

// ==================== SESSION MANAGEMENT ====================
class Session {
    private String sessionId;
    private String creatorId;
    private String title;
    private String description;
    private SessionStatus status;
    private List<TimeSlot> availableSlots;
    private SessionPricing pricing;
    private int maxParticipants;
    private Duration duration;
    private String meetingLink;
    private List<String> tags;
    private Instant createdAt;
    private Instant updatedAt;

    // Session Builder
    public static class Builder {
        private String sessionId;
        private String creatorId;
        private String title;
        private Duration duration;
        private SessionPricing pricing;

        public Builder sessionId(String sessionId) {
            this.sessionId = sessionId;
            return this;
        }

        public Builder creatorId(String creatorId) {
            this.creatorId = creatorId;
            return this;
        }

        public Builder title(String title) {
            this.title = title;
            return this;
        }

        public Builder duration(Duration duration) {
            this.duration = duration;
            return this;
        }

        public Builder pricing(SessionPricing pricing) {
            this.pricing = pricing;
            return this;
        }

        public Session build() {
            return new Session(this);
        }
    }

    private Session(Builder builder) {
        this.sessionId = builder.sessionId;
        this.creatorId = builder.creatorId;
        this.title = builder.title;
        this.duration = builder.duration;
        this.pricing = builder.pricing;
        this.status = SessionStatus.DRAFT;
        this.availableSlots = new ArrayList<>();
        this.maxParticipants = 1;
        this.tags = new ArrayList<>();
        this.createdAt = Instant.now();
        this.updatedAt = Instant.now();
    }

    public void publish() {
        if (availableSlots.isEmpty()) {
            throw new IllegalStateException("Cannot publish without available slots");
        }
        this.status = SessionStatus.PUBLISHED;
        this.updatedAt = Instant.now();
    }

    public void addTimeSlot(TimeSlot slot) {
        // Check for overlaps
        for (TimeSlot existing : availableSlots) {
            if (existing.overlaps(slot)) {
                throw new IllegalArgumentException("Time slot overlaps with existing slot");
            }
        }
        availableSlots.add(slot);
    }

    public List<TimeSlot> getAvailableSlots() {
        return availableSlots.stream()
            .filter(slot -> !slot.isBooked())
            .collect(Collectors.toList());
    }
}

// ==================== STRATEGY PATTERN: Pricing ====================
interface PricingStrategy {
    double calculatePrice(double basePrice);
    String getDescription();
}

class FixedPricingStrategy implements PricingStrategy {
    @Override
    public double calculatePrice(double basePrice) {
        return basePrice;
    }

    @Override
    public String getDescription() {
        return "Fixed Pricing";
    }
}

class TieredPricingStrategy implements PricingStrategy {
    private int minSessions;
    private double discountPercentage;

    public TieredPricingStrategy(int minSessions, double discountPercentage) {
        this.minSessions = minSessions;
        this.discountPercentage = discountPercentage;
    }

    @Override
    public double calculatePrice(double basePrice) {
        return basePrice * (1 - discountPercentage / 100);
    }

    @Override
    public String getDescription() {
        return String.format("Tiered (%d+ sessions, %.1f%% off)", 
                           minSessions, discountPercentage);
    }
}

class SessionPricing {
    private double amount;
    private Currency currency;
    private PricingStrategy strategy;
    private double platformFeePercentage;

    public SessionPricing(double amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
        this.strategy = new FixedPricingStrategy();
        this.platformFeePercentage = 15.0; // 15% platform fee
    }

    public double getFinalPrice() {
        return strategy.calculatePrice(amount);
    }

    public double getPlatformFee() {
        return getFinalPrice() * (platformFeePercentage / 100);
    }

    public double getCreatorEarnings() {
        return getFinalPrice() - getPlatformFee();
    }
}

// ==================== BOOKING SYSTEM ====================
class Booking {
    private String bookingId;
    private String sessionId;
    private String userId;
    private TimeSlot timeSlot;
    private BookingStatus status;
    private PaymentDetails paymentDetails;
    private String notes;
    private Instant bookedAt;
    private List<BookingEvent> events;

    public Booking(String bookingId, String sessionId, String userId, TimeSlot timeSlot) {
        this.bookingId = bookingId;
        this.sessionId = sessionId;
        this.userId = userId;
        this.timeSlot = timeSlot;
        this.status = BookingStatus.PENDING;
        this.events = new ArrayList<>();
        this.bookedAt = Instant.now();
        addEvent("Booking created", BookingStatus.PENDING);
    }

    public void confirm(PaymentDetails payment) {
        this.paymentDetails = payment;
        this.status = BookingStatus.CONFIRMED;
        addEvent("Booking confirmed", BookingStatus.CONFIRMED);
    }

    public void cancel(String cancelledBy, String reason) {
        if (this.status == BookingStatus.COMPLETED) {
            throw new IllegalStateException("Cannot cancel completed booking");
        }

        if ("CREATOR".equals(cancelledBy)) {
            this.status = BookingStatus.CANCELLED_BY_CREATOR;
        } else {
            this.status = BookingStatus.CANCELLED_BY_USER;
        }

        addEvent("Booking cancelled: " + reason, this.status);
    }

    public void markCompleted() {
        this.status = BookingStatus.COMPLETED;
        addEvent("Session completed", BookingStatus.COMPLETED);
    }

    private void addEvent(String description, BookingStatus status) {
        events.add(new BookingEvent(
            description, 
            status, 
            Instant.now()
        ));
    }
}

class BookingEvent {
    private String description;
    private BookingStatus status;
    private Instant timestamp;

    public BookingEvent(String description, BookingStatus status, Instant timestamp) {
        this.description = description;
        this.status = status;
        this.timestamp = timestamp;
    }
}

// ==================== STRATEGY PATTERN: Payment Gateway ====================
interface PaymentGateway {
    PaymentResponse processPayment(PaymentRequest request);
    PaymentResponse refundPayment(String transactionId, double amount);
}

class StripePaymentGateway implements PaymentGateway {
    @Override
    public PaymentResponse processPayment(PaymentRequest request) {
        // Integration with Stripe API
        System.out.println("Processing payment via Stripe: " + request.getAmount());
        return new PaymentResponse(
            "txn_" + UUID.randomUUID(),
            PaymentStatus.PROCESSING,
            Instant.now()
        );
    }

    @Override
    public PaymentResponse refundPayment(String transactionId, double amount) {
        System.out.println("Refunding via Stripe: " + transactionId);
        return new PaymentResponse(
            transactionId,
            PaymentStatus.REFUNDED,
            Instant.now()
        );
    }
}

class RazorpayPaymentGateway implements PaymentGateway {
    @Override
    public PaymentResponse processPayment(PaymentRequest request) {
        // Integration with Razorpay API
        System.out.println("Processing payment via Razorpay: " + request.getAmount());
        return new PaymentResponse(
            "rzp_txn_" + UUID.randomUUID(),
            PaymentStatus.PROCESSING,
            Instant.now()
        );
    }

    @Override
    public PaymentResponse refundPayment(String transactionId, double amount) {
        System.out.println("Refunding via Razorpay: " + transactionId);
        return new PaymentResponse(
            transactionId,
            PaymentStatus.REFUNDED,
            Instant.now()
        );
    }
}

class PaymentRequest {
    private String bookingId;
    private double amount;
    private Currency currency;
    private String paymentMethodId;
    private Map<String, String> metadata;

    // Builder pattern for PaymentRequest
}

class PaymentResponse {
    private String transactionId;
    private PaymentStatus status;
    private Instant processedAt;
    private String gatewayResponse;

    public PaymentResponse(String transactionId, PaymentStatus status, Instant processedAt) {
        this.transactionId = transactionId;
        this.status = status;
        this.processedAt = processedAt;
    }
}

class PaymentDetails {
    private String paymentId;
    private double amount;
    private Currency currency;
    private String gatewayTransactionId;
    private PaymentStatus status;
    private Instant paidAt;

    public PaymentDetails(String paymentId, double amount, Currency currency) {
        this.paymentId = paymentId;
        this.amount = amount;
        this.currency = currency;
        this.status = PaymentStatus.PENDING;
    }
}

// ==================== FACTORY PATTERN: Notifications ====================
interface Notification {
    void send();
    NotificationType getType();
}

class EmailNotification implements Notification {
    private String to;
    private String subject;
    private String body;
    private Map<String, String> templateData;

    public EmailNotification(String to, String subject, String body) {
        this.to = to;
        this.subject = subject;
        this.body = body;
        this.templateData = new HashMap<>();
    }

    @Override
    public void send() {
        // Integrate with email service (SendGrid, AWS SES, etc.)
        System.out.println("Sending email to: " + to);
        System.out.println("Subject: " + subject);
        System.out.println("Body: " + body);
    }

    @Override
    public NotificationType getType() {
        return NotificationType.EMAIL;
    }
}

class SMSNotification implements Notification {
    private String phoneNumber;
    private String message;

    @Override
    public void send() {
        // Integrate with SMS service (Twilio, etc.)
        System.out.println("Sending SMS to: " + phoneNumber);
        System.out.println("Message: " + message);
    }

    @Override
    public NotificationType getType() {
        return NotificationType.SMS;
    }
}

class PushNotification implements Notification {
    private String deviceToken;
    private String title;
    private String body;
    private Map<String, String> data;

    @Override
    public void send() {
        // Integrate with FCM/APNS
        System.out.println("Sending push notification to device: " + deviceToken);
    }

    @Override
    public NotificationType getType() {
        return NotificationType.PUSH;
    }
}

interface NotificationFactory {
    Notification createNotification(NotificationType type, Map<String, String> params);
}

class SimpleNotificationFactory implements NotificationFactory {
    @Override
    public Notification createNotification(NotificationType type, Map<String, String> params) {
        switch (type) {
            case EMAIL:
                return new EmailNotification(
                    params.get("to"),
                    params.get("subject"),
                    params.get("body")
                );
            case SMS:
                return new SMSNotification();
            case PUSH:
                return new PushNotification();
            default:
                throw new IllegalArgumentException("Unsupported notification type");
        }
    }
}

// ==================== OBSERVER PATTERN: Event System ====================
interface EventListener {
    void onEvent(SystemEvent event);
}

class SystemEvent {
    private String eventType;
    private String entityId;
    private Map<String, Object> payload;
    private Instant timestamp;

    public SystemEvent(String eventType, String entityId) {
        this.eventType = eventType;
        this.entityId = entityId;
        this.payload = new HashMap<>();
        this.timestamp = Instant.now();
    }

    public SystemEvent withPayload(String key, Object value) {
        this.payload.put(key, value);
        return this;
    }
}

class EventManager {
    private Map<String, List<EventListener>> listeners;
    private static EventManager instance;

    private EventManager() {
        this.listeners = new HashMap<>();
    }

    public static synchronized EventManager getInstance() {
        if (instance == null) {
            instance = new EventManager();
        }
        return instance;
    }

    public void subscribe(String eventType, EventListener listener) {
        listeners.computeIfAbsent(eventType, k -> new ArrayList<>())
                .add(listener);
    }

    public void unsubscribe(String eventType, EventListener listener) {
        List<EventListener> eventListeners = listeners.get(eventType);
        if (eventListeners != null) {
            eventListeners.remove(listener);
        }
    }

    public void publish(SystemEvent event) {
        List<EventListener> eventListeners = listeners.get(event.getEventType());
        if (eventListeners != null) {
            for (EventListener listener : eventListeners) {
                listener.onEvent(event);
            }
        }
    }
}

// ==================== PROXY PATTERN: Caching Proxy ====================
interface SessionRepository {
    Session findById(String sessionId);
    List<Session> findByCreatorId(String creatorId);
    void save(Session session);
}

class RealSessionRepository implements SessionRepository {
    // Database implementation
    @Override
    public Session findById(String sessionId) {
        System.out.println("Fetching session from database: " + sessionId);
        // Database query logic
        return null;
    }

    @Override
    public List<Session> findByCreatorId(String creatorId) {
        // Database query logic
        return new ArrayList<>();
    }

    @Override
    public void save(Session session) {
        // Database save logic
        System.out.println("Saving session to database: " + session.getSessionId());
    }
}

class CachedSessionRepository implements SessionRepository {
    private SessionRepository realRepository;
    private Map<String, Session> cache;
    private Map<String, Instant> cacheTimestamps;
    private Duration cacheTTL;

    public CachedSessionRepository(SessionRepository realRepository) {
        this.realRepository = realRepository;
        this.cache = new HashMap<>();
        this.cacheTimestamps = new HashMap<>();
        this.cacheTTL = Duration.ofMinutes(5);
    }

    @Override
    public Session findById(String sessionId) {
        // Check cache first
        if (cache.containsKey(sessionId)) {
            Instant cachedTime = cacheTimestamps.get(sessionId);
            if (Instant.now().minus(cacheTTL).isBefore(cachedTime)) {
                System.out.println("Returning cached session: " + sessionId);
                return cache.get(sessionId);
            } else {
                // Cache expired
                cache.remove(sessionId);
                cacheTimestamps.remove(sessionId);
            }
        }

        // Fetch from real repository
        Session session = realRepository.findById(sessionId);
        if (session != null) {
            cache.put(sessionId, session);
            cacheTimestamps.put(sessionId, Instant.now());
        }

        return session;
    }

    @Override
    public List<Session> findByCreatorId(String creatorId) {
        // This could also be cached with a different key strategy
        return realRepository.findByCreatorId(creatorId);
    }

    @Override
    public void save(Session session) {
        // Update cache on save
        realRepository.save(session);
        cache.put(session.getSessionId(), session);
        cacheTimestamps.put(session.getSessionId(), Instant.now());
    }

    public void invalidateCache(String sessionId) {
        cache.remove(sessionId);
        cacheTimestamps.remove(sessionId);
    }
}

// ==================== MAIN TOPMATE SYSTEM ====================
class TopmateSystem {
    private static TopmateSystem instance;
    private Map<String, User> users;
    private Map<String, CreatorProfile> creatorProfiles;
    private SessionRepository sessionRepository;
    private Map<String, Booking> bookings;
    private PaymentGateway paymentGateway;
    private NotificationFactory notificationFactory;
    private EventManager eventManager;
    private RateLimiter rateLimiter;

    private TopmateSystem() {
        this.users = new HashMap<>();
        this.creatorProfiles = new HashMap<>();
        this.sessionRepository = new CachedSessionRepository(new RealSessionRepository());
        this.bookings = new HashMap<>();
        this.paymentGateway = new StripePaymentGateway(); // Default
        this.notificationFactory = new SimpleNotificationFactory();
        this.eventManager = EventManager.getInstance();
        this.rateLimiter = new RateLimiter(100, Duration.ofMinutes(1)); // 100 requests per minute

        setupEventListeners();
    }

    public static synchronized TopmateSystem getInstance() {
        if (instance == null) {
            instance = new TopmateSystem();
        }
        return instance;
    }

    private void setupEventListeners() {
        // Listen for booking events
        eventManager.subscribe("BOOKING_CREATED", new EventListener() {
            @Override
            public void onEvent(SystemEvent event) {
                sendBookingConfirmation(event);
            }
        });

        eventManager.subscribe("SESSION_COMPLETED", new EventListener() {
            @Override
            public void onEvent(SystemEvent event) {
                updateCreatorStats(event);
            }
        });
    }

    // ==================== CORE BUSINESS METHODS ====================

    public User registerUser(String email, String displayName, UserType userType) {
        if (!rateLimiter.allowRequest("REGISTER_" + email)) {
            throw new RuntimeException("Rate limit exceeded");
        }

        String userId = "user_" + UUID.randomUUID().toString().substring(0, 8);
        User user = new User.Builder()
            .userId(userId)
            .email(email)
            .displayName(displayName)
            .userType(userType)
            .build();

        users.put(userId, user);

        if (userType == UserType.CREATOR) {
            creatorProfiles.put(userId, new CreatorProfile(userId));
        }

        eventManager.publish(new SystemEvent("USER_REGISTERED", userId)
            .withPayload("email", email)
            .withPayload("userType", userType));

        return user;
    }

    public Session createSession(String creatorId, Session.Builder sessionBuilder) {
        if (!users.containsKey(creatorId) || !users.get(creatorId).isCreator()) {
            throw new IllegalArgumentException("User is not a creator");
        }

        Session session = sessionBuilder.build();
        sessionRepository.save(session);

        eventManager.publish(new SystemEvent("SESSION_CREATED", session.getSessionId())
            .withPayload("creatorId", creatorId)
            .withPayload("title", session.getTitle()));

        return session;
    }

    public Booking bookSession(String sessionId, String userId, TimeSlot timeSlot) {
        // Check rate limiting
        if (!rateLimiter.allowRequest("BOOK_" + userId)) {
            throw new RuntimeException("Rate limit exceeded");
        }

        Session session = sessionRepository.findById(sessionId);
        if (session == null) {
            throw new IllegalArgumentException("Session not found");
        }

        // Check if slot is available
        boolean slotAvailable = session.getAvailableSlots().stream()
            .anyMatch(slot -> slot.equals(timeSlot));

        if (!slotAvailable) {
            throw new IllegalArgumentException("Time slot not available");
        }

        String bookingId = "booking_" + UUID.randomUUID().toString().substring(0, 8);
        Booking booking = new Booking(bookingId, sessionId, userId, timeSlot);
        bookings.put(bookingId, booking);

        // Mark slot as booked
        timeSlot.markAsBooked();

        eventManager.publish(new SystemEvent("BOOKING_CREATED", bookingId)
            .withPayload("sessionId", sessionId)
            .withPayload("userId", userId)
            .withPayload("timeSlot", timeSlot));

        return booking;
    }

    public PaymentResponse processPayment(String bookingId, PaymentRequest paymentRequest) {
        Booking booking = bookings.get(bookingId);
        if (booking == null) {
            throw new IllegalArgumentException("Booking not found");
        }

        PaymentResponse response = paymentGateway.processPayment(paymentRequest);

        if (response.getStatus() == PaymentStatus.PROCESSING) {
            booking.confirm(new PaymentDetails(
                response.getTransactionId(),
                paymentRequest.getAmount(),
                paymentRequest.getCurrency()
            ));

            // Send notifications
            sendBookingConfirmationNotifications(booking);
        }

        return response;
    }

    public void cancelBooking(String bookingId, String cancelledBy, String reason) {
        Booking booking = bookings.get(bookingId);
        if (booking == null) {
            throw new IllegalArgumentException("Booking not found");
        }

        booking.cancel(cancelledBy, reason);

        // Process refund if payment was made
        if (booking.getPaymentDetails() != null && 
            booking.getPaymentDetails().getStatus() == PaymentStatus.COMPLETED) {
            processRefund(booking);
        }

        eventManager.publish(new SystemEvent("BOOKING_CANCELLED", bookingId)
            .withPayload("cancelledBy", cancelledBy)
            .withPayload("reason", reason));
    }

    private void processRefund(Booking booking) {
        PaymentDetails payment = booking.getPaymentDetails();
        PaymentResponse refundResponse = paymentGateway.refundPayment(
            payment.getGatewayTransactionId(),
            payment.getAmount()
        );

        if (refundResponse.getStatus() == PaymentStatus.REFUNDED) {
            payment.setStatus(PaymentStatus.REFUNDED);
        }
    }

    private void sendBookingConfirmationNotifications(Booking booking) {
        String userId = booking.getUserId();
        User user = users.get(userId);

        // Send email notification
        Notification emailNotification = notificationFactory.createNotification(
            NotificationType.EMAIL,
            Map.of(
                "to", user.getEmail(),
                "subject", "Booking Confirmation",
                "body", "Your booking has been confirmed!"
            )
        );
        emailNotification.send();

        // Send in-app notification
        sendInAppNotification(userId, "Booking confirmed", 
            "Your session has been booked successfully");
    }

    private void sendInAppNotification(String userId, String title, String message) {
        // Store notification in database for user's notification center
        System.out.println("In-app notification sent to user: " + userId);
    }

    private void sendBookingConfirmation(SystemEvent event) {
        System.out.println("Processing booking confirmation for event: " + event.getEventType());
    }

    private void updateCreatorStats(SystemEvent event) {
        System.out.println("Updating creator stats for event: " + event.getEventType());
    }

    // ==================== QUERY METHODS ====================

    public List<Session> searchSessions(String query, List<String> tags, 
                                       Instant fromDate, Instant toDate) {
        // Implement search logic with filters
        return new ArrayList<>();
    }

    public List<TimeSlot> getAvailableSlots(String sessionId) {
        Session session = sessionRepository.findById(sessionId);
        return session != null ? session.getAvailableSlots() : new ArrayList<>();
    }

    public List<Booking> getUserBookings(String userId) {
        return bookings.values().stream()
            .filter(booking -> booking.getUserId().equals(userId))
            .collect(Collectors.toList());
    }

    public List<Booking> getCreatorBookings(String creatorId) {
        // Get all sessions by creator, then get bookings for those sessions
        List<Session> creatorSessions = sessionRepository.findByCreatorId(creatorId);
        Set<String> sessionIds = creatorSessions.stream()
            .map(Session::getSessionId)
            .collect(Collectors.toSet());

        return bookings.values().stream()
            .filter(booking -> sessionIds.contains(booking.getSessionId()))
            .collect(Collectors.toList());
    }

    // ==================== ADMIN METHODS ====================

    public void setPaymentGateway(PaymentGateway gateway) {
        this.paymentGateway = gateway;
    }

    public double calculatePlatformRevenue(Instant from, Instant to) {
        return bookings.values().stream()
            .filter(booking -> booking.getBookedAt().isAfter(from) && 
                              booking.getBookedAt().isBefore(to))
            .filter(booking -> booking.getStatus() == BookingStatus.COMPLETED)
            .mapToDouble(booking -> {
                // Calculate platform fee from each completed booking
                // This would need to fetch session pricing details
                return 0.0; // Placeholder
            })
            .sum();
    }
}

// ==================== RATE LIMITER ====================
class RateLimiter {
    private int maxRequests;
    private Duration timeWindow;
    private Map<String, List<Instant>> requestLog;

    public RateLimiter(int maxRequests, Duration timeWindow) {
        this.maxRequests = maxRequests;
        this.timeWindow = timeWindow;
        this.requestLog = new HashMap<>();
    }

    public synchronized boolean allowRequest(String key) {
        Instant now = Instant.now();
        Instant windowStart = now.minus(timeWindow);

        List<Instant> requests = requestLog.computeIfAbsent(key, k -> new ArrayList<>());

        // Remove old requests
        requests.removeIf(timestamp -> timestamp.isBefore(windowStart));

        if (requests.size() < maxRequests) {
            requests.add(now);
            return true;
        }

        return false;
    }
}

// ==================== DEMO / TEST ====================
public class TopmateDemo {
    public static void main(String[] args) {
        TopmateSystem system = TopmateSystem.getInstance();

        System.out.println("=== TOPMATE DEMO ===\n");

        // 1. Register users
        System.out.println("1. Registering users...");
        User creator = system.registerUser(
            "creator@example.com", 
            "John Doe", 
            UserType.CREATOR
        );

        User consumer = system.registerUser(
            "consumer@example.com", 
            "Jane Smith", 
            UserType.CONSUMER
        );

        System.out.println("Creator ID: " + creator.getUserId());
        System.out.println("Consumer ID: " + consumer.getUserId());

        // 2. Create a session
        System.out.println("\n2. Creating a session...");
        SessionPricing pricing = new SessionPricing(50.0, Currency.USD);

        Session session = system.createSession(
            creator.getUserId(),
            new Session.Builder()
                .sessionId("session_" + UUID.randomUUID().toString().substring(0, 8))
                .creatorId(creator.getUserId())
                .title("Career Coaching Session")
                .duration(Duration.ofHours(1))
                .pricing(pricing)
        );

        // Add time slots
        TimeSlot slot1 = new TimeSlot.Builder()
            .startTime(Instant.now().plus(Duration.ofDays(1)))
            .duration(Duration.ofHours(1))
            .build();

        session.addTimeSlot(slot1);
        session.publish();

        System.out.println("Session created: " + session.getTitle());
        System.out.println("Price: $" + session.getPricing().getFinalPrice());

        // 3. Book a session
        System.out.println("\n3. Booking the session...");
        Booking booking = system.bookSession(
            session.getSessionId(),
            consumer.getUserId(),
            slot1
        );

        System.out.println("Booking created: " + booking.getBookingId());
        System.out.println("Status: " + booking.getStatus());

        // 4. Process payment
        System.out.println("\n4. Processing payment...");
        PaymentRequest paymentRequest = new PaymentRequest();
        paymentRequest.setBookingId(booking.getBookingId());
        paymentRequest.setAmount(50.0);
        paymentRequest.setCurrency(Currency.USD);
        paymentRequest.setPaymentMethodId("pm_card_visa");

        PaymentResponse paymentResponse = system.processPayment(
            booking.getBookingId(),
            paymentRequest
        );

        System.out.println("Payment processed: " + paymentResponse.getTransactionId());
        System.out.println("Payment status: " + paymentResponse.getStatus());

        // 5. Complete the session
        System.out.println("\n5. Completing the session...");
        booking.markCompleted();
        System.out.println("Session completed!");

        // 6. Query bookings
        System.out.println("\n6. Querying user bookings...");
        List<Booking> userBookings = system.getUserBookings(consumer.getUserId());
        System.out.println("User has " + userBookings.size() + " booking(s)");

        // 7. Switch payment gateway
        System.out.println("\n7. Switching payment gateway...");
        system.setPaymentGateway(new RazorpayPaymentGateway());
        System.out.println("Payment gateway switched to Razorpay");

        // 8. Test rate limiting
        System.out.println("\n8. Testing rate limiting...");
        RateLimiter rateLimiter = new RateLimiter(3, Duration.ofSeconds(10));
        for (int i = 0; i < 5; i++) {
            boolean allowed = rateLimiter.allowRequest("TEST_KEY");
            System.out.println("Request " + (i + 1) + ": " + 
                             (allowed ? "Allowed" : "Blocked (rate limit)"));
        }

        System.out.println("\n=== DEMO COMPLETE ===");
    }
}

Key Features Implemented:

1. User Management

Creator and consumer roles
Profile management with verification
Social links and expertise tags

2. Session Management

Multiple time slots
Pricing strategies (fixed, tiered)
Session status lifecycle

3. Booking System

Real-time availability checking
Booking status tracking
Cancellation with refunds

4. Payment Integration

Multiple payment gateways (Stripe, Razorpay)
Platform commission calculation
Refund processing

5. Notification System

Multiple channels (email, SMS, push, in-app)
Template-based notifications
Event-driven architecture

6. Performance & Scalability

Caching with Proxy pattern
Rate limiting
Efficient querying

7. Analytics & Reporting

Creator performance metrics
Platform revenue calculation
Booking analytics

8. Security & Reliability

Input validation
Transaction consistency
Error handling and retry mechanisms

This design provides a scalable, maintainable foundation for a platform like Topmate with clear separation of concerns and extensibility for future features.

Issues in Above Design

1️⃣ Global Singleton (`TopmateSystem`) → Scalability + Concurrency Bottleneck

Issue

TopmateSystem is a god-object singleton managing:

Users
Sessions
Bookings
Payments
Notifications
Rate limiting

LLD Problem

Violates Single Responsibility Principle
Tight coupling between unrelated domains
Hard to test in isolation

Concurrency Problem

All operations funnel through a single shared instance

Shared mutable maps:

  Map<String, User> users;
  Map<String, Booking> bookings;

Impact

Race conditions on shared state
Poor horizontal scalability
Difficult to shard by user / creator / region

Solution

will be covered in our premium course.

2️⃣ Time Slot Booking Is Not Atomic (CRITICAL)

Issue

Booking flow:

check slot availability
create booking
mark slot as booked

LLD Problem

Slot availability logic lives inside Session
No booking aggregate boundary

Concurrency Problem

Two users can book the same TimeSlot simultaneously
Classic check-then-act race condition

Example Failure

Thread A: slot is free ✅
Thread B: slot is free ✅
Thread A: books slot
Thread B: books same slot ❌

Impact

Double bookings
Refund storms
Loss of trust

Solution

will be covered in our premium course.

3️⃣ TimeSlot Mutability Without Synchronization

Issue

TimeSlot.isBooked is a mutable boolean.

LLD Problem

TimeSlot is a value object but behaves like an entity
No invariant enforcement

Concurrency Problem

No synchronization / CAS when marking booked
Writes are not atomic across threads

Impact

Inconsistent availability views
Stale reads in cached sessions

Solution

will be covered in our premium course.

4️⃣ In-Memory Maps Are Not Thread-Safe

Issue

Core storage uses:

HashMap
ArrayList

LLD Problem

Persistence and domain logic mixed
Repository pattern partially implemented

Concurrency Problem

Concurrent modification exceptions
Lost updates during parallel bookings / registrations

Affected Areas

users
bookings
creatorProfiles
EventManager.listeners
CachedSessionRepository.cache

Solution

will be covered in our premium course.

5️⃣ CachedSessionRepository Is Not Thread-Safe

Issue

Map<String, Session> cache;
Map<String, Instant> cacheTimestamps;

LLD Problem

Cache logic embedded in repository
No invalidation strategy on slot booking

Concurrency Problem

Race between:
- booking a slot
- reading cached session

Impact

Users see slots that are already booked
Cache inconsistency across threads

Solution

will be covered in our premium course.

6️⃣ Event System Is Synchronous and Unsafe

Issue

eventManager.publish(event);

LLD Problem

Core business logic depends on listeners
No failure isolation

Concurrency Problem

One slow listener blocks publisher thread
Concurrent modifications to listeners list

Impact

Booking latency spikes
Notification failures block core flows

Solution

will be covered in our premium course.

7️⃣ Payment Flow Lacks Idempotency (Very High Risk)

Issue

processPayment() assumes single execution.

LLD Problem

No Payment aggregate with state machine
Payment gateway retries not modeled

Concurrency Problem

Gateway retries → duplicate confirmations
Multiple threads can confirm same booking

Impact

Double charges
Inconsistent booking/payment states
Revenue reconciliation issues

Solution

will be covered in our premium course.

8️⃣ Booking State Transitions Are Not Guarded

Issue

Booking status changes:

confirm()
cancel()
markCompleted()

LLD Problem

No state machine validation
Transitions allowed from invalid states

Concurrency Problem

Concurrent:
- cancel vs confirm
- refund vs completion

Impact

Booking ends in impossible state
Refund after completion
Creator payout mismatches

Solution

will be covered in our premium course.

9️⃣ RateLimiter Is Coarse-Grained and Contended

Issue

synchronized boolean allowRequest()

LLD Problem

Rate limiting embedded in domain logic
No distributed support

Concurrency Problem

Lock contention under high traffic
Hot keys (popular creators) block others

Impact

Artificial throttling
Latency spikes during campaigns

Solution

will be covered in our premium course.

🔟 No Transaction Boundary Across Booking + Payment + Slot Lock

Issue

Booking flow spans:

Slot marking
Booking creation
Payment processing
Notification publishing

LLD Problem

No transaction boundary
No saga or orchestration

Concurrency Problem

Partial failures leave system inconsistent

Impact

Slot booked but payment failed
Payment succeeded but booking cancelled
Notifications sent for rolled-back bookings

Solution

will be covered in our premium course.

Features Required

1. User Management

2. Session Management

3. Booking System

4. Payment & Pricing

5. Notifications

9. Search & Query

10. Admin Features

Design Patterns Used

1. Builder Pattern

2. Factory Pattern

3. Strategy Pattern

4. Observer Pattern

5. Proxy Pattern

6. Singleton Pattern

7. Repository Pattern

Java Implementation

Key Features Implemented:

1. User Management

2. Session Management

3. Booking System

4. Payment Integration

5. Notification System

6. Performance & Scalability

7. Analytics & Reporting

8. Security & Reliability

Issues in Above Design

1️⃣ Global Singleton (TopmateSystem) → Scalability + Concurrency Bottleneck

Issue

LLD Problem

Concurrency Problem

Impact

Solution

2️⃣ Time Slot Booking Is Not Atomic (CRITICAL)

Issue

LLD Problem

Concurrency Problem

Example Failure

Impact

Solution

3️⃣ TimeSlot Mutability Without Synchronization

Issue

LLD Problem

Concurrency Problem

Impact

Solution

4️⃣ In-Memory Maps Are Not Thread-Safe

Issue

LLD Problem

Concurrency Problem

Affected Areas

Solution

5️⃣ CachedSessionRepository Is Not Thread-Safe

Issue

LLD Problem

Concurrency Problem

Impact

Solution

6️⃣ Event System Is Synchronous and Unsafe

Issue

LLD Problem

Concurrency Problem

Impact

Solution

7️⃣ Payment Flow Lacks Idempotency (Very High Risk)

Issue

LLD Problem

Concurrency Problem

Impact

Solution

8️⃣ Booking State Transitions Are Not Guarded

Issue

LLD Problem

Concurrency Problem

Impact

Solution

9️⃣ RateLimiter Is Coarse-Grained and Contended

Issue

LLD Problem

Concurrency Problem

1️⃣ Global Singleton (`TopmateSystem`) → Scalability + Concurrency Bottleneck

Design (LLD) Topmate - Machine Coding