main.py

import sys
import os

import auth
import mail
import ui
import utils
import settings
from utils import print_info, print_error, print_success, clear

VERSION = "1.0.0"

demo_mode = "--demo" in sys.argv
if demo_mode:
    import demo


def help_message():
    print("""
Available commands:

Reading and Navigation:
----------------------------------------------------------------------------
    inbox                         -> Fetch and display emails in the inbox
    view <email_id>               -> View the full content of an email
    open <email_id>               -> Open email in browser
    next                          -> View the next page
    prev                          -> View the previous page
    page <page_number>            -> Change to a specific page
    label <label>                 -> Switch to a different label
    search <query>                -> Search emails
    download <email_id> <number>  -> Download an attachment from an email
    
Composing and Sending:
----------------------------------------------------------------------------
    write                         -> Compose and send a new email
    reply <email_id>              -> Reply to an email
    forward <email_id>            -> Forward an email
    edit <email_id>               -> Edit a draft email

Email Actions:
----------------------------------------------------------------------------
    star <email_id>               -> Star an email
    unstar <email_id>             -> Unstar an email
    unread <email_id>             -> Mark an email as unread
    delete <email_id>             -> Delete an email
    untrash <email_id>            -> Move an email back to inbox from trash
    archive <email_id>            -> Archive an email

Custom labels:
----------------------------------------------------------------------------
    newlabel <name>               -> Create a new label
    deletelabel <name>            -> Delete a label
    renamelabel <old> <new>       -> Rename a label
    setlabel <email_id> <label>   -> Apply a label to an email
    unsetlabel <email_id> <label> -> Remove a label from an email

Settings, Account and Aliases:
----------------------------------------------------------------------------
    settings                      -> View your settings
    setting <name> <value>        -> Change a specific setting
    alias [<alias> [<command>]]   -> Manage command aliases
    unalias <alias>               -> Remove a command alias
    accounts                      -> List saved accounts
    addaccount                    -> Add a new account
    switchaccount <email>         -> Switch to a different account
    removeaccount <email>         -> Remove an account
    help                          -> Show this help message
    version                       -> Show application version
    exit, quit                    -> Exit the application
    """)


connection = None

current_emails = []

current_labels = []
current_label = "INBOX"
default_labels = {}

current_page = 1
total_pages = 1

settings_vals = {}


def resolve_label(id):
    for email in current_emails:
        if str(email["id"]) == str(id):
            stored = email.get("label")
            if stored:
                return stored

    return current_label


def load_inbox():
    global current_emails
    global total_pages
    
    print_info("Fetching emails...")
    emails_per_page = settings_vals.get("emails_per_page", 20)
    current_emails = mail.get_inbox(connection, current_label, current_page, emails_per_page)
    total_pages = mail.get_total_pages(connection, current_label, emails_per_page)

    is_sent_label = current_label == default_labels.get("sent", "")
    
    ui.print_inbox(current_emails, current_label, current_labels, current_page, total_pages, is_sent=is_sent_label)


def parse_command(input_command):
    parts = input_command.strip().split()

    if not parts:
        return None, None
    
    command = parts[0].lower()
    args = parts[1:]

    aliases = settings_vals.get("aliases", {})
    if command in aliases:
        full_command = aliases[command].strip().split()
        command = full_command[0].lower()
        args = full_command[1:] + args

    return command, args


def execute_command(command, args):
    global current_labels
    global current_label
    global current_emails
    global current_page, total_pages
    global connection
    global default_labels
    
    if command == "exit" or command == "quit":
        clear()
        print_info("Goodbye!")
        return False


    elif command == "help":
        clear()
        help_message()


    elif command == "inbox":
        clear()

        current_page = 1
        load_inbox()


    elif command == "next":
        if current_page >= total_pages:
            print_info("This is the last page")
            return True
        
        clear()

        current_page += 1
        load_inbox()


    elif command == "prev":
        if current_page <= 1:
            print_info("This is the first page")
            return True
        
        clear()

        current_page -= 1
        load_inbox()


    elif command == "page":
        if len(args) != 1:
            print_error("Usage: page <page_number>")
            return True
        
        try:
            page_number = int(args[0])
        except ValueError:
            print_error("Page number must be a number.")
            return True
        
        if page_number < 1 or page_number > total_pages:
            print_error(f"You have only {total_pages} pages.")
            return True
        
        clear()

        current_page = page_number
        load_inbox()


    elif command == "view":
        if len(args) != 1:
            print_error("Usage: view <email_id>")
            return True
        
        try:
            email_id = int(args[0])

        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            clear()

            all_label = default_labels.get("all", "[Gmail]/All Mail")
            thread = mail.get_thread(connection, str(email_id), resolve_label(email_id), all_label)
            if not thread:
                email_data = mail.get_email(connection, str(email_id), resolve_label(email_id))

                if email_data is None:
                    print_error(f"Email with ID {email_id} not found.")
                    return True
                
                thread = [email_data]
            
            if settings_vals.get("auto_mark_read", True):
                mail.mark_as_read(connection, str(email_id), resolve_label(email_id))

            current_emails = thread

            ui.print_email(thread)

        except Exception as e:
            print_error(f"Error email: {str(e)}")


    elif command == "open":
        if len(args) != 1:
            print_error("Usage: open <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            print_info("Processing...")
            all_label = default_labels.get("all", "[Gmail]/All Mail")
            thread = mail.get_thread(connection, str(email_id), resolve_label(email_id), all_label)
            if not thread:
                email_data = mail.get_email(connection, str(email_id), resolve_label(email_id))

                if email_data is None:
                    print_error(f"Email with ID {email_id} not found.")
                    return True
                
                thread = [email_data]
            
            mail.open_in_browser(thread)
        
        except Exception as e:
            print_error(f"Error: {str(e)}")


    elif command == "download":
        if len(args) != 2:
            print_error("Usage: download <email_id> <attachment_number>")
            return True
        
        try:
            email_id = int(args[0])
            attachment_number = int(args[1]) - 1
        except ValueError:
            print_error("Email ID and attachment number must be numbers.")
            return True
        
        try:
            print_info("Processing...")
            email_data = mail.get_email(connection, str(email_id), resolve_label(email_id))

            if email_data is None:
                print_error(f"Email with ID {email_id} not found.")
                return True

            utils_down_folder = utils.get_download_folder()
            folder = settings_vals.get("download_folder", utils_down_folder)
            if not os.path.isdir(folder):
                print_error(f"Download folder '{folder}' does not exist.")
                return True
            
            path = mail.download_attachment(email_data, attachment_number, folder, resolve_label(email_id))
            if path:
                print_success(f"Attachment downloaded to: {path}")

        except Exception as e:
            print_error(f"Error: {str(e)}")

    
    elif command == "label":
        if len(args) < 1:
            print_error("Usage: label <label>")
            return True
        
        label_name = " ".join(args)

        clear()

        if label_name.isdigit():
            index = int(label_name) - 1

            if index >= 0 and index < len(current_labels):
                current_label = current_labels[index]["name"]
                current_page = 1

            else:
                print_error("Invalid label")
                return True
            
        else:
            label_name = " ".join(args)
            match = False

            for la in current_labels:
                if la["display"].lower() == label_name.lower():
                    current_label = la["name"]
                    match = True
                    break

            if not match:
                print_error(f"Label '{label_name}' not found.")
                return True

        load_inbox()


    elif command == "write":
        clear()
        
        signature = settings_vals.get("signature")
        to, cc, bcc, subject, body, attachments, is_draft = ui.compose_editor(signature=signature)

        if is_draft:
            mail.save_draft(connection, to, subject, body, cc=cc, bcc=bcc, draft_label=default_labels.get("drafts", "[Gmail]/Drafts"))
            print_success("Draft saved.")
            return True
        
        if to is None:
            clear()
            load_inbox()
            return True
        
        clear()

        confirm = ui.confirm_send(to, cc, bcc, subject, body, attachments=attachments)
        if not confirm:
            print_info("Email discarded.")

        else:
            success = mail.send_email(connection, to, subject, body, attachments=attachments, cc=cc, bcc=bcc)
            if success:
                print_success("Email sent!")


    elif command == "reply":
        if len(args) != 1:
            clear()
            print_error("Usage: reply <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            clear()

            email_data = mail.get_email(connection, str(email_id), resolve_label(email_id))
            if email_data is None:
                print_error(f"Email with ID {email_id} not found.")
                return True

            reply_to = email_data["from"]
            reply_subject = f"Re: {email_data['subject']}"

            signature = settings_vals.get("signature", "")
            to, cc, bcc, subject, body, attachments, is_draft = ui.compose_editor(to=reply_to, subject=reply_subject, quote=email_data["body"], signature=signature)
            
            if is_draft:
                mail.save_draft(connection, to, subject, body, cc=cc, bcc=bcc, draft_label=default_labels.get("drafts", "[Gmail]/Drafts"))
                print_success("Draft saved.")
                return True

            if to is None:
                clear()
                load_inbox()
                return True

            clear()
            
            confirm = ui.confirm_send(to, cc, bcc, subject, body, attachments=attachments)
            if not confirm:
                print_info("Email discarded.")

            else:
                success = mail.send_email(connection, to, subject, body, reply_to=email_data["message_id"], parents=email_data["references"], attachments=attachments, cc=cc, bcc=bcc)
                if success:
                    print_success("Email sent!")

        except Exception as e:
            print_error(f"Error replying to email: {str(e)}")

    
    elif command == "forward":
        if len(args) != 1:
            print_error("Usage: forward <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            clear()

            email_data = mail.get_email(connection, str(email_id), resolve_label(email_id))
            if email_data is None:
                print_error(f"Email with ID {email_id} not found.")
                return True
            
            subject = f"Fwd: {email_data['subject']}"

            quote = (
                f"----------Forwarded message----------\n"
                f"From: {email_data['from']}\n"
                f"Date: {email_data['date']}\n"
                f"Subject: {email_data['subject']}\n"
                f"To: {email_data['to']}\n\n"
                f"{email_data['body']}"
            )

            signature = settings_vals.get("signature", "")
            to, cc, bcc, subject, body, attachments, is_draft = ui.compose_editor(subject=subject, quote=quote, signature=signature)

            if is_draft:
                mail.save_draft(connection, to, subject, body, cc=cc, bcc=bcc, draft_label=default_labels.get("drafts", "[Gmail]/Drafts"))
                print_success("Draft saved.")
                return True
            
            if to is None:
                clear()
                load_inbox()
                return True
            
            clear()

            confirm = ui.confirm_send(to, cc, bcc, subject, body, attachments=attachments)
            if not confirm:
                print_info("Email discarded.")
            else:
                success = mail.send_email(connection, to, subject, body, attachments=attachments, cc=cc, bcc=bcc)
                if success:
                    print_success("Email sent!")
            
        except Exception as e:
            print_error(f"Error forwarding email: {str(e)}")


    elif command == "edit":
        if len(args) != 1:
            print_error("Usage: edit <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            clear()

            drafts_label = default_labels.get("drafts", "[Gmail]/Drafts")

            draft = mail.get_email(connection, str(email_id), drafts_label)
            if draft is None:
                print_error(f"Draft with ID {email_id} not found.")
                return True
            
            to, cc, bcc, subject, body, attachments, is_draft = ui.compose_editor(to=draft["to"], cc=draft["cc"], bcc=draft["bcc"], subject=draft["subject"], body=draft["body"])

            if to is None and not is_draft:
                clear()
                load_inbox()
                return True
            
            mail.delete_draft(connection, str(email_id), drafts_label)

            if is_draft:
                mail.save_draft(connection, to, subject, body, cc=cc, bcc=bcc, draft_label=drafts_label)
                print_success("Draft updated.")
                return True
            
            clear()

            confirm = ui.confirm_send(to, cc, bcc, subject, body, attachments=attachments)
            if not confirm:
                mail.save_draft(connection, to, subject, body, cc=cc, bcc=bcc, draft_label=drafts_label)
                print_info("Email discarded, draft updated.")
            
            else:
                success = mail.send_email(connection, to, subject, body, attachments=attachments, cc=cc, bcc=bcc)
                if success:
                    print_success("Email sent!")

        except Exception as e:
            print_error(f"Error in draft: {str(e)}")
            return True


    elif command == "search":
        if len(args) < 1:
            print_error("Usage: search <query>")
            return True
        
        query = " ".join(args).strip('"').strip("'")
        
        clear()
        print_info(f"Searching for '{query}'...")

        try:
            results = mail.search_emails(connection, query, current_label)

            current_emails = results
            ui.print_search_inbox(results, query, current_label, current_labels)

        except Exception as e:
            print_error(f"Error searching emails: {str(e)}")


    elif command == "newlabel":
        if len(args) < 1:
            print_error("Usage: newlabel <name>")
            return True
        
        name = " ".join(args)

        try:
            mail.create_label(connection, name)
            current_labels = mail.get_labels(connection)
            print_success(f"Label '{name}' created.")

        except Exception as e:
            print_error(f"Error creating label: {str(e)}")
        
    
    elif command == "deletelabel":
        if len(args) < 1:
            print_error("Usage: deletelabel <name>")
            return True
        
        name = " ".join(args)

        try:
            mail.delete_label(connection, name)
            current_labels = mail.get_labels(connection)
            print_success(f"Label '{name}' deleted.")

        except Exception as e:
            print_error(f"Error deleting label: {str(e)}")

    
    elif command == "renamelabel":
        if len(args) < 2:
            print_error("Usage: renamelabel <old_name> <new_name>")
            return True
        
        command = " ".join(args)
        if '"' in command:
            parts = []
            for p in command.split('"'):
                if p.strip():
                    parts.append(p.strip())
        
        else:
            parts = command.split(None, 1)

        if len(parts) < 2:
            print_error('Usage: renamelabel "old_name" "new_name"')
            return True

        old_name = parts[0]
        new_name = parts[1]

        try:
            mail.rename_label(connection, old_name, new_name)
            current_labels = mail.get_labels(connection)
            if current_label == old_name:
                current_label = new_name
                
            print_success(f"Label '{old_name}' renamed to '{new_name}'")
        
        except Exception as e:
            print_error(f"Error renaming label: {str(e)}")


    elif command == "setlabel":
        if len(args) < 2:
            print_error("Usage: setlabel <email_id> <label>")
            return True
        
        email_id = args[0]
        label_name = " ".join(args[1:])

        match = None
        for label in current_labels:
            if label["display"].lower() == label_name.lower():
                match = label
                break

        if match is None:
            print_error(f"Label '{label_name}' not found.")
            return True

        try:
            mail.set_label(connection, str(email_id), match["name"], resolve_label(email_id))
            print_success(f"Label '{label_name}' set to the email.")

        except Exception as e:
            print_error(f"Error setting label: {str(e)}")


    elif command == "unsetlabel":
        if len(args) < 2:
            print_error("Usage: unsetlabel <email_id> <label>")
            return True
        
        email_id = args[0]
        label_name = " ".join(args[1:])
    
        match = None
        for label in current_labels:
            if label["display"].lower() == label_name.lower():
                match = label
                break

        if match is None:
            print_error(f"Label '{label_name}' not found.")
            return True

        try:
            mail.unset_label(connection, str(email_id), match["name"], resolve_label(email_id))
            print_success(f"Label '{label_name}' removed from the email.")

        except Exception as e:
            print_error(f"Error removing label: {str(e)}")


    elif command == "star":
        if len(args) != 1:
            print_error("Usage: star <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            mail.star_email(connection, str(email_id), resolve_label(email_id))
            print_success(f"Email {email_id} starred.")

        except Exception as e:
            print_error(f"Error starring email: {str(e)}")

    
    elif command == "unstar":
        if len(args) != 1:
            print_error("Usage: unstar <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            mail.unstar_email(connection, str(email_id), resolve_label(email_id))
            print_success(f"Email {email_id} unstarred.")

        except Exception as e:
            print_error(f"Error unstarring email: {str(e)}")

        
    elif command == "unread":
        if len(args) != 1:
            print_error("Usage: unread <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            mail.mark_unread(connection, str(email_id), resolve_label(email_id))
            print_success(f"Email {email_id} marked as unread.")

        except Exception as e:
            print_error(f"Error marking email as unread: {str(e)}")

    
    elif command == "delete":
        if len(args) != 1:
            print_error("Usage: delete <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            mail.delete_email(connection, str(email_id), resolve_label(email_id), trash_label=default_labels.get("trash", "[Gmail]/Trash"))
            print_success(f"Email {email_id} deleted.")

        except Exception as e:
            print_error(f"Error deleting email: {str(e)}")

        
    elif command == "untrash":
        if len(args) != 1:
            print_error("Usage: untrash <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            if resolve_label(email_id) != default_labels.get("trash", "[Gmail]/Trash"):
                print_error(f"Email {email_id} is not in trash.")
                return True
            
            success = mail.untrash_email(connection, str(email_id), trash_label=default_labels.get("trash", "[Gmail]/Trash"), inbox_label=default_labels.get("inbox", "INBOX"), all_label=default_labels.get("all", "[Gmail]/All Mail"))
            if success:
                print_success(f"Email {email_id} moved back to inbox.")
            else:
                print_error(f"Email {email_id} not found in trash.")

        except Exception as e:
            print_error(f"Error untrash email: {str(e)}")

    
    elif command == "archive":
        if len(args) != 1:
            print_error("Usage: archive <email_id>")
            return True
        
        try:
            email_id = int(args[0])
        except ValueError:
            print_error("Email ID must be a number.")
            return True
        
        try:
            mail.archive_email(connection, str(email_id), resolve_label(email_id), all_label=default_labels.get("all", "[Gmail]/All Mail"))
            print_success(f"Email {email_id} archived.")
        
        except Exception as e:
            print_error(f"Error archiving email: {str(e)}")

    
    elif command == "settings":
        clear()

        ui.print_settings(settings_vals)

    
    elif command == "setting":
        if len(args) < 1:
            print_error("Usage: setting <name> <value>")
            return True
        
        setting_name = args[0]
        new_value = " ".join(args[1:]).strip('"').strip("'")

        default = settings.default_settings.get(setting_name)
        if len(args) == 1:
            if isinstance(default, int) or isinstance(default, bool):
                print_error(f"Usage: setting {setting_name} <value>")
                return True
            
        if setting_name not in settings_vals:
            print_error(f"Unknown setting: {setting_name}")
            return True

        settingg = settings.default_settings.get(setting_name)
        current_value = settings_vals.get(setting_name)

        try:
            if isinstance(settingg, bool) or isinstance(current_value, bool):
                if new_value.lower() == "true":
                    value = True
                elif new_value.lower() == "false":
                    value = False
                else:
                    raise ValueError("Invalid boolean value")
            elif isinstance(settingg, int):
                value = int(new_value)
            else:
                value = new_value

        except ValueError:
            print_error(f"Invalid value for setting {setting_name}")
            return True
        
        settings_vals[setting_name] = value
        settings.save_settings(settings_vals)
        print_success(f"Setting '{setting_name}' updated to '{value}'.")


    elif command == "alias":
        if len(args) == 0:
            clear()
            ui.print_aliases(settings_vals.get("aliases", {}))
            return True

        elif len(args) == 1:
            alias = args[0]
            aliases = settings_vals.get("aliases", {})
            if alias in aliases:
                print_info(f"{alias} -> {aliases[alias]}")
            else:
                print_info(f"No alias found for '{alias}'.")
            
        elif len(args) >= 2:
            alias = args[0]
            command_alias = " ".join(args[1:])

            if not settings_vals.get("aliases"):
                settings_vals["aliases"] = {}
            
            settings_vals["aliases"][alias] = command_alias
            settings.save_settings(settings_vals)
            print_success(f"Alias '{alias}' created.")

        else:
            print_error("Usage: alias [<alias> [<command>]]")
            return True
        

    elif command == "unalias":
        if len(args) != 1:
            print_error("Usage: unalias <alias>")
            return True
        
        alias = args[0]
        aliases = settings_vals.get("aliases", {})
        if alias not in aliases:
            print_error(f"No alias found for '{alias}'.")
            return True
        
        del aliases[alias]
        settings_vals["aliases"] = aliases
        settings.save_settings(settings_vals)
        print_success(f"Alias '{alias}' removed.")


    elif command == "accounts":
        clear()

        ui.print_accounts(auth.list_accounts(), auth.load_account())


    elif command == "addaccount":
        clear()

        while True:
            email, password = auth.add_account()
            if not email or not password:
                print_error("Email or password cannot be empty.")
                break

            try:
                test_connection = mail.connect(email, password)
                mail.disconnect(test_connection)
                print_success(f"Account {email} added to keychain.")
                break

            except Exception as e:
                print_error(f"Failed to connect: {str(e)}")
                print_error("Please check your credentials and try again.")
                auth.remove_account(email)
        
    
    elif command == "switchaccount":
        if len(args) != 1:
            print_error("Usage: switchaccount <email>")
            return True
        
        email = args[0]
        if email not in auth.list_accounts():
            print_error(f"No account found for {email}")
            return True
        
        clear()

        password = auth.get_password(email)
        try:
            mail.disconnect(connection)
            connection = mail.connect(email, password)
            auth.active(email)
            
            current_labels = mail.get_labels(connection)
            default_labels = mail.get_default_labels(connection)
            current_label = "INBOX"
            current_page = 1

            print_success(f"Switched to {email}")
            load_inbox()
        
        except Exception as e:
            print_error(f"Failed switch: {str(e)}")
            return True
        

    elif command == "removeaccount":
        if len(args) != 1:
            print_error("Usage: removeaccount <email>")
            return True
        
        email = args[0]
        if email not in auth.list_accounts():
            print_error(f"No account found for {email}")
            return True

        clear()
        
        confirm = ui.confirm_remove_account(email)
        if confirm:
            auth.remove_account(email)
            print_success(f"Account {email} removed.")

            clear()

            new = auth.load_account()
            if new:
                password = auth.get_password(new)
                try:
                    mail.disconnect(connection)
                    connection = mail.connect(new, password)
                    auth.active(new)

                    current_labels = mail.get_labels(connection)
                    default_labels = mail.get_default_labels(connection)
                    current_label = "INBOX"
                    current_page = 1

                    print_success(f"Switched to {new}")
                    load_inbox()

                except Exception as e:
                    print_error(f"Failed switch: {str(e)}")
                    return True
                    
        else:
            print_info("Aborted")


    elif command == "version":
        print_info(f"""CLI-Inbox v{VERSION}
----------------
GitHub    : https://github.com/artur3333/CLI-Inbox
License   : MIT""")


    else:
        print_error(f"Unknown command: {command}")
    
    return True


def main():
    global connection
    global current_labels
    global default_labels
    global settings_vals
    global current_label

    clear()
    if demo_mode:
        connection = mail.connect("", "")
        print_success("Connected in demo mode.")
        
    else:
        account = auth.load_account()

        if account:
            password = auth.get_password(account)
            try:
                connection = mail.connect(account, password)
                print_success("Connected")
            
            except Exception as e:
                print_error(f"Failed to connect: {str(e)}")
                print_error("Please check your credentials and try again.")
                auth.remove_account(account)
                account = None

        if not account:
            while True:
                email, password = auth.setup_account()
                if email and password:
                    try:
                        connection = mail.connect(email, password)
                        print_success(f"Account {email} saved to keychain.")
                        print_success("Connected")
                        break

                    except Exception as e:
                        print_error(f"Failed to connect: {str(e)}")
                        print_error("Please check your credentials and try again.")
                        auth.remove_account(email)
    
    settings_vals = settings.load_settings()
    
    current_labels = mail.get_labels(connection)
    default_labels = mail.get_default_labels(connection)

    startup_label = settings_vals.get("default_label", "INBOX").strip()
    if startup_label != "INBOX":
        found = False
        for label in current_labels:
            if label["display"].lower() == startup_label.lower():
                current_label = label["name"]
                found = True
                break
        
        if not found:
            print_error(f"Default label '{startup_label}' not found. Loading INBOX")
            current_label = "INBOX"
    
    load_inbox()

    running = True
    while running:
        try:
            if demo_mode:
                prompt = "\n[DEMO] > "
            else:
                prompt = "\n> "
            
            command = input(prompt).strip()
            if not command:
                continue
            
            command, args = parse_command(command)

            if command:
                running = execute_command(command, args)
            
        except KeyboardInterrupt:
            print("\n")
            print_info("Use 'exit' or 'quit' to exit.")

        except Exception as e:
            print_error(f"Error: {str(e)}")

    
    if connection:
        mail.disconnect(connection)
        

if __name__ == "__main__":
    main()