Features Required:

User Registration and Authentication: Users should be able to create accounts, log in, and authenticate themselves to access their emails.
Email Composing and Sending: Users should be able to compose and send emails to other users.
Email Inbox: Users should have an inbox where they can receive and view their received emails.
Email Read and Unread Status: Emails should have read and unread status to track the user's interaction with each email.
Email Labels and Categories: Users should be able to categorize their emails using labels, such as "Personal," "Work," "Important," etc.
Email Search: Users should be able to search for specific emails based on keywords, sender, date, etc.
Attachments: Users should be able to attach files to their emails.
Email Forwarding and Reply: Users should be able to forward emails to other users or reply to received emails.
Drafts: Users should be able to save drafts of their composed emails for future editing and sending.
Email Deletion and Trash: Users should be able to delete emails, and deleted emails should be moved to the trash folder.
Email Archiving: Users should have the option to archive emails to declutter their inbox while preserving important emails.

Design Patterns Involved or Used:

Model-View-Controller (MVC) Pattern: The MVC pattern can be used to separate the application into three components: the model (data and business logic), the view (user interface), and the controller (handles user interactions and manages the flow of data).
Observer Pattern: The Observer pattern can be used to notify users about new emails and updates to email read/unread status.
Factory Pattern: The Factory pattern can be used to create different types of email objects based on user requests, such as sent emails, received emails, drafts, etc.
Singleton Pattern: The Singleton pattern can be used to ensure that only one instance of certain classes, such as the user authentication manager or the email manager, is created and shared across the application.
Proxy Pattern: The Proxy pattern can be used to handle communication between the application and the email server, providing a level of indirection and encapsulation for network operations.
Command Pattern: The Command pattern can be used to encapsulate and decouple actions, such as sending emails or deleting emails, from the specific objects or components that perform those actions.
Publish-Subscribe Pattern: The Publish-Subscribe pattern can be used to implement the email notification system, where users subscribe to their inbox to receive updates on new emails, and publishers send email updates to the subscribers.
Decorator Pattern: The Decorator pattern can be used to add additional features or behaviors to email objects, such as email labels and categories.
Strategy Pattern: The Strategy pattern can be used to implement different search algorithms for searching emails based on different criteria, such as keywords, sender, or date.
State Pattern: The State pattern can be used to manage the different states of email interactions, such as composing, reading, or deleting emails.

Code: Detailed Implementation of Classes Based on Each Design Pattern Mentioned Above

// User class
class User {
    private String userId;
    private String username;
    private String password;
    // Other attributes and methods

    public User(String userId, String username, String password) {
        this.userId = userId;
        this.username = username;
        this.password = password;
    }

    // Getters and setters
    // Other user-related methods
}

// Email class
class Email {
    private String emailId;
    private User sender;
    private List<User> receivers;
    private String subject;
    private String body;
    private LocalDateTime timestamp;
    private boolean isRead;
    private List<String> labels;
    private List<String> attachments;
    // Other attributes and methods

    public Email(String emailId, User sender, List<User> receivers, String subject, String body) {
        this.emailId = emailId;
        this.sender = sender;
        this.receivers = receivers;
        this.subject = subject;
        this.body = body;
        this.timestamp = LocalDateTime.now();
        this.isRead = false;
        this.labels = new ArrayList<>();
        this.attachments = new ArrayList<>();
    }

    // Getters and setters
    // Methods for adding and removing receivers, labels, and attachments
}

// EmailManager class
class EmailManager {
    private List<Email> inbox;
    private List<Email> sent;
    private List<Email> drafts;
    private List<Email> trash;
    // Other attributes and methods

    public EmailManager() {
        this.inbox = new ArrayList<>();
        this.sent = new ArrayList<>();
        this.drafts = new ArrayList<>();
        this.trash = new ArrayList<>();
    }

    public void sendEmail(Email email) {
        // Send the email and add it to the sent folder
    }

    public void receiveEmail(Email email) {
        inbox.add(email);
        // Notify observers about new received email
    }

    public void moveEmailToTrash(Email email) {
        inbox.remove(email);
        drafts.remove(email);
        sent.remove(email);
        trash.add(email);
    }

    // Other email management methods
}

// EmailSearchStrategy interface (Strategy)
interface EmailSearchStrategy {
    List<Email> searchEmails(List<Email> emails, String keyword);
}

// KeywordSearchStrategy class (Strategy)
class KeywordSearchStrategy implements EmailSearchStrategy {
    @Override
    public List<Email> searchEmails(List<Email> emails, String keyword) {
        // Implement keyword-based email search
    }
}

// SenderSearchStrategy class (Strategy)
class SenderSearchStrategy implements EmailSearchStrategy {
    @Override
    public List<Email> searchEmails(List<Email> emails, String sender) {
        // Implement sender-based email search
    }
}

// SearchManager class
class SearchManager {
    private EmailSearchStrategy searchStrategy;

    public void setSearchStrategy(EmailSearchStrategy searchStrategy) {
        this.searchStrategy = searchStrategy;
    }

    public List<Email> searchEmails(List<Email> emails, String keyword) {
        return searchStrategy.searchEmails(emails, keyword);
    }
}

// PresenceObserver interface
interface PresenceObserver {
    void onPresenceChange(User user, boolean online);
}

// PresenceManager class (Singleton)
class PresenceManager {
    private static PresenceManager instance;
    private Map<User, Boolean> presenceMap;
    private List<PresenceObserver> observers;

    private PresenceManager() {
        this.presenceMap = new HashMap<>();
        this.observers = new ArrayList<>();
    }

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

    public void setPresence(User user, boolean online) {
        presenceMap.put(user, online);
        notifyObservers(user, online);
    }

    public void addObserver(PresenceObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(PresenceObserver observer) {
        observers.remove(observer);
    }

    private void notifyObservers(User user, boolean online) {
        for (PresenceObserver observer : observers) {
            observer.onPresenceChange(user, online);
        }
    }
}

// EmailNotificationObserver class (Observer)
class EmailNotificationObserver implements PresenceObserver {
    private User user;

    public EmailNotificationObserver(User user) {
        this.user = user;
    }

    @Override
    public void onPresenceChange(User user, boolean online) {
        // Notify the user about new emails when they come online
        if (user.equals(this.user) && online) {
            // Check for new emails and display notifications
        }
    }
}

// EmailLabelsDecorator class (Decorator)
class EmailLabelsDecorator extends Email {
    private Email email;

    public EmailLabelsDecorator(Email email) {
        super(email.getEmailId(), email.getSender(), email.getReceivers(), email.getSubject(), email.getBody());
        this.email = email;
    }

    @Override
    public List<String> getLabels() {
        List<String> labels = new ArrayList<>(email.getLabels());
        labels.add("Important");
        return labels;
    }
}

// EmailState interface (State)
interface EmailState {
    void handleEmail(Email email);
}

// DraftState class (State)
class DraftState implements EmailState {
    @Override
    public void handleEmail(Email email) {
        // Handle email actions in draft state (e.g., saving drafts, editing)
    }
}

// SentState class (State)
class SentState implements EmailState {
    @Override
    public void handleEmail(Email email) {
        // Handle email actions in sent state (e.g., marking as sent, archiving)
    }
}

// InboxState class (State)
class InboxState implements EmailState {
    @Override
    public void handleEmail(Email email) {
        // Handle email actions in inbox state (e.g., marking as read, replying)
    }
}

// EmailStateContext class
class EmailStateContext {
    private EmailState currentState;

    public EmailStateContext() {
        this.currentState = new DraftState();
    }

    public void setState(EmailState state) {
        this.currentState = state;
    }

    public void handleEmail(Email email) {
        currentState.handleEmail(email);
    }
}

// Main Class
public class GmailApp {
    public static void main(String[] args) {
        // Create users
        User user1 = new User("user1", "john.doe@gmail.com", "password1");
        User user2 = new User("user2", "alice.smith@gmail.com", "password2");

        // Create email objects
        Email email1 = new Email("email1", user1, List.of(user2), "Hello", "Hi Alice, how are you?");
        Email email2 = new Email("email2", user2, List.of(user1), "Re: Hello", "Hi John, I'm doing well.");

        // Create email manager
        EmailManager emailManager = new EmailManager();

        // Receive emails
        emailManager.receiveEmail(email1);
        emailManager.receiveEmail(email2);

        // Move an email to trash
        emailManager.moveEmailToTrash(email1);

        // Search emails
        SearchManager searchManager = new SearchManager();
        searchManager.setSearchStrategy(new KeywordSearchStrategy());
        List<Email> searchResults = searchManager.searchEmails(emailManager.getInbox(), "John");

        // Add labels to emails using decorators
        Email emailWithLabel = new EmailLabelsDecorator(email2);
        emailWithLabel.getLabels(); // Returns ["Important"]

        // Set email state and handle actions
        EmailStateContext stateContext = new EmailStateContext();
        stateContext.setState(new InboxState());
        stateContext.handleEmail(email2);
    }
}

In this code example, the User class represents a Gmail user, the Email class represents an email object, the EmailManager class manages the user's emails in different folders (inbox, sent, drafts, trash), the SearchManager class uses the Strategy pattern to implement different email search algorithms, the PresenceManager class manages the presence and online status of users, the EmailNotificationObserver class observes the presence changes of users and displays email notifications when users come online, the EmailLabelsDecorator class adds the "Important" label to emails using the Decorator pattern, and the EmailStateContext class manages the state of emails (draft, sent, inbox) using the State pattern.

Please note that this is a simplified example, and a complete implementation of Gmail involves more complex components, such as email storage and retrieval, email threading and conversation management, user contact management, email attachments handling, spam filtering, integration with SMTP and IMAP protocols, and user interface design for composing, reading, and managing emails. Additionally, Gmail is a large-scale system that requires robust architecture and distributed infrastructure to handle millions of users and their emails efficiently.

Issues in Above Design

🔥 Problem 1: Email Is a Mutable Object (🚨 Fundamental Flaw)

❌ What we Did

class Email {
    boolean isRead;
    List<String> labels;
}

❌ Why This Is Dangerous

Emails are:

Immutable messages
With per-user metadata

💥 Reality:

Sender’s copy ≠ Receiver’s copy
Read/unread is user-specific
Labels are user-specific

Your design:

Mutates the same Email object for everyone

🎯 Interviewer Question:

“If Alice reads the email, why does Bob’s email become read?”

Solution

will be covered in our premium course.

🔥 Problem 2: EmailManager Is Not a Singleton (But Should Be)

❌ What we Did

class EmailManager {
    List<Email> inbox;
}

❌ Why This Breaks Instantly

Where is the source of truth?
Multiple EmailManagers = inconsistent state
No per-user isolation

💥 Result:

Two instances → two inboxes → lost emails

🎯 Interviewer Thought:

“This can’t work beyond one JVM.”

Solution

will be covered in our premium course.

🔥 Problem 3: Observer Pattern Used for Core Email Delivery (Wrong)

❌ What we Did

receiveEmail() {
   inbox.add(email);
   notifyObservers();
}

❌ Why This Is Architecturally Wrong

Observers:

Can fail
Are async
Are best-effort

Email delivery:

Must be guaranteed
Must survive crashes
Must be retryable

💥 Result:

Observer fails → email lost forever

🎯 Interviewer Reaction:

“Observers are for UI, not delivery.”

Solution

will be covered in our premium course.

🔥 Problem 4: Search Is In-Memory (Unscalable)

❌ What we Did

List<Email> searchEmails(List<Email> emails)

❌ Why This Fails Immediately

Gmail has billions of emails
Search is:
- Indexed
- Tokenized
- Precomputed

💥 Result:

O(N) search per query = dead system

🎯 Interviewer Question:

“How does Gmail search 10GB mailbox in 20ms?”

Solution

will be covered in our premium course.

🔥 Problem 5: Decorator for Labels Is Conceptually Wrong

❌ What we Did

class EmailLabelsDecorator extends Email

❌ Why This Is a Misuse

Labels are:

User metadata
Many-to-many
Dynamic

Decorator:

Creates new object
Copies data
Breaks identity

💥 Result:

Same email, different objects, different IDs

🎯 Interviewer Thought:

“This breaks threading and conversations.”

Solution

will be covered in our premium course.

🔥 Problem 6: Email State Pattern Is Artificial

❌ What we Did

DraftState, SentState, InboxState

❌ Why This Is Over-Engineering

States are:

Folder placements
Not behavioral modes

Email does not “behave differently”
User actions do.

💥 Result:

Pattern without real value

🎯 Interviewer Reaction:

“State pattern is forced here.”

Solution

will be covered in our premium course.

🔥 Problem 7: No Email Threading / Conversations

❌ What’s Missing Entirely

Message-ID
In-Reply-To
References
Thread grouping

💥 Result:

Inbox becomes flat chaos

🎯 Interviewer Question:

“How does Gmail group replies?”

Solution

will be covered in our premium course.

🔥 Problem 8: Attachments Stored Inside Email Object

❌ What we Did

List<String> attachments;

❌ Why This Is Dangerous

Attachments are large
Need deduplication
Need virus scanning
Need object storage

💥 Result:

JVM OOM in production

🎯 Interviewer Thought:

“This candidate hasn’t built storage systems.”

Solution

will be covered in our premium course.

🔥 Problem 9: No Concurrency Model

❌ Missing Completely

Two devices marking read
Search + delete race
Label update conflicts

💥 Result:

Lost updates, inconsistent inbox

🎯 Interviewer Question:

“What happens if I delete and archive at same time?”

Solution

will be covered in our premium course.

Design (LLD) Gmail - Machine Coding