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.

Design (LLD) Gmail - Machine Coding