main.py

"""
Random Password Generator
--------------------------
A menu-driven console application that generates cryptographically
secure random passwords made up of letters and numbers.

DecodeLabs Python Programming Internship - Project 3

Built using only the Python Standard Library:
    - secrets  : cryptographically secure random selection
    - string   : predefined character set constants

No external packages, GUI frameworks, databases, or file storage
are used. Nothing is stored permanently; all data lives only for
the duration of a single program run.
"""

import string
import secrets


# --------------------------------------------------------------------------
# Configuration / Constants
# --------------------------------------------------------------------------

DEFAULT_PASSWORD_LENGTH = 12
MIN_PASSWORD_LENGTH = 4
MAX_PASSWORD_LENGTH = 128
CHARACTER_POOL = string.ascii_letters + string.digits


# --------------------------------------------------------------------------
# Input Validation
# --------------------------------------------------------------------------

def get_valid_length(prompt_message, current_length):
    """
    Prompt the user for a password length and validate the input.

    Rejects empty input, non-numeric values, zero, and negative
    numbers. Also enforces a sane upper bound so the program stays
    responsive. The function loops until valid input is given, or
    the user submits nothing meaningful more than once in a row is
    still handled gracefully (no crash).

    Returns:
        int: A validated password length, or the current_length
             unchanged if the user cancels by typing 'c'.
    """
    while True:
        raw_input_value = input(prompt_message).strip()

        # Allow the user to cancel out of changing the length.
        if raw_input_value.lower() == "c":
            print("Cancelled. Length unchanged.\n")
            return current_length

        # Reject empty input.
        if raw_input_value == "":
            print("Input cannot be empty. Please enter a number.\n")
            continue

        # Reject non-numeric values (also protects against decimals
        # like "8.5" since int() would raise ValueError on those too).
        try:
            length_value = int(raw_input_value)
        except ValueError:
            print("Invalid input. Please enter a whole number.\n")
            continue

        # Reject zero and negative numbers.
        if length_value <= 0:
            print("Password length must be a positive number.\n")
            continue

        # Reject unreasonably large values.
        if length_value < MIN_PASSWORD_LENGTH:
            print(f"Password length must be at least {MIN_PASSWORD_LENGTH}.\n")
            continue

        if length_value > MAX_PASSWORD_LENGTH:
            print(f"Password length cannot exceed {MAX_PASSWORD_LENGTH}.\n")
            continue

        return length_value


def get_valid_count(prompt_message):
    """
    Prompt the user for how many passwords to generate at once.

    Rejects empty input, non-numeric values, zero, and negative
    numbers, and caps the count to keep output readable.

    Returns:
        int: A validated count of passwords to generate.
    """
    while True:
        raw_input_value = input(prompt_message).strip()

        if raw_input_value == "":
            print("Input cannot be empty. Please enter a number.\n")
            continue

        try:
            count_value = int(raw_input_value)
        except ValueError:
            print("Invalid input. Please enter a whole number.\n")
            continue

        if count_value <= 0:
            print("Count must be a positive number.\n")
            continue

        if count_value > 50:
            print("Please request 50 or fewer passwords at a time.\n")
            continue

        return count_value


# --------------------------------------------------------------------------
# Core Password Generation Logic
# --------------------------------------------------------------------------

def generate_password(password_length):
    """
    Generate a single random password using letters and numbers.

    Uses secrets.choice() rather than the random module because
    secrets draws from the operating system's cryptographically
    secure entropy source, making the output suitable for security
    related purposes such as account passwords.

    String characters are collected in a list and joined once at
    the end with ''.join(), avoiding the inefficiency of repeatedly
    concatenating immutable strings inside a loop.

    Args:
        password_length (int): Number of characters in the password.

    Returns:
        str: The generated password.
    """
    password_characters = [secrets.choice(CHARACTER_POOL) for _ in range(password_length)]
    return "".join(password_characters)


def generate_multiple_passwords(password_length, how_many):
    """
    Generate several random passwords of the same length.

    Args:
        password_length (int): Number of characters per password.
        how_many (int): Number of passwords to generate.

    Returns:
        list[str]: A list of generated passwords.
    """
    return [generate_password(password_length) for _ in range(how_many)]


# --------------------------------------------------------------------------
# Menu Actions
# --------------------------------------------------------------------------

def handle_generate_password(current_length):
    """Generate and display a single password using the current settings."""
    password = generate_password(current_length)
    print(f"\nGenerated Password: {password}\n")


def handle_change_length(current_length):
    """Prompt for and return a new password length."""
    print(f"\nCurrent password length: {current_length}")
    new_length = get_valid_length(
        "Enter new password length (or 'c' to cancel): ", current_length
    )
    if new_length != current_length:
        print(f"Password length updated to {new_length}.\n")
    return new_length


def handle_generate_multiple(current_length):
    """Generate and display several passwords using the current settings."""
    count = get_valid_count("How many passwords would you like to generate? ")
    passwords = generate_multiple_passwords(current_length, count)
    print(f"\nGenerated {count} Password(s):")
    for index, password in enumerate(passwords, start=1):
        print(f"  {index}. {password}")
    print()


def handle_view_settings(current_length):
    """Display the current configuration of the password generator."""
    print("\nCurrent Settings")
    print("-----------------")
    print(f"Password Length : {current_length}")
    print(f"Character Pool  : Letters (A-Z, a-z) and Numbers (0-9)")
    print(f"Pool Size       : {len(CHARACTER_POOL)} characters\n")


def handle_reset_settings():
    """Reset settings back to the application default and return it."""
    print(f"\nSettings have been reset to default (length = {DEFAULT_PASSWORD_LENGTH}).\n")
    return DEFAULT_PASSWORD_LENGTH


# --------------------------------------------------------------------------
# Menu Display
# --------------------------------------------------------------------------

def display_menu():
    """Print the main menu options."""
    print("=" * 40)
    print("      RANDOM PASSWORD GENERATOR")
    print("=" * 40)
    print("1. Generate Password")
    print("2. Change Password Length")
    print("3. Generate Multiple Passwords")
    print("4. View Current Settings")
    print("5. Reset Settings")
    print("6. Exit")
    print("=" * 40)


def get_menu_choice():
    """
    Prompt for and validate the user's menu selection.

    Rejects empty input and non-numeric values, and re-prompts on
    any choice outside the valid menu range. Never crashes on bad
    input.

    Returns:
        int: A validated menu choice between 1 and 6.
    """
    while True:
        raw_choice = input("Select an option (1-6): ").strip()

        if raw_choice == "":
            print("Input cannot be empty. Please choose an option.\n")
            continue

        try:
            choice_value = int(raw_choice)
        except ValueError:
            print("Invalid input. Please enter a number between 1 and 6.\n")
            continue

        if choice_value < 1 or choice_value > 6:
            print("Please choose a number between 1 and 6.\n")
            continue

        return choice_value


# --------------------------------------------------------------------------
# Main Application Loop
# --------------------------------------------------------------------------

def main():
    """Run the interactive password generator until the user exits."""
    current_length = DEFAULT_PASSWORD_LENGTH

    print("Welcome to the Random Password Generator!")
    print(f"Default password length is set to {DEFAULT_PASSWORD_LENGTH}.\n")

    while True:
        display_menu()
        choice = get_menu_choice()
        print()

        if choice == 1:
            handle_generate_password(current_length)
        elif choice == 2:
            current_length = handle_change_length(current_length)
        elif choice == 3:
            handle_generate_multiple(current_length)
        elif choice == 4:
            handle_view_settings(current_length)
        elif choice == 5:
            current_length = handle_reset_settings()
        elif choice == 6:
            print("Thank you for using the Random Password Generator. Goodbye!")
            break


if __name__ == "__main__":
    try:
        main()
    except (KeyboardInterrupt, EOFError):
        print("\n\nProgram interrupted. Goodbye!")