# Basic while loop syntax
# while condition:
#     code to repeat

# Simple counting example
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1  # Important: modify the condition variable!

print("Loop finished!")

# While loop with user input
response = ""
while response != "quit":
    response = input("Enter &apos;quit&apos; to exit: ")
    if response != "quit":
        print(f"You entered: {response}")

print("Goodbye!")

# While loop with boolean condition
game_running = True
player_score = 0

while game_running:
    print(f"Current score: {player_score}")
    action = input("Enter action (play/quit): ")
    
    if action == "play":
        player_score += 10
        print("You scored 10 points!")
    elif action == "quit":
        game_running = False
    else:
        print("Invalid action")

print(f"Final score: {player_score}")

# While loop with complex condition
attempts = 0
max_attempts = 3
success = False

while attempts < max_attempts and not success:
    password = input(f"Enter password (attempt {attempts + 1}/{max_attempts}): ")
    
    if password == "secret123":
        success = True
        print("Access granted!")
    else:
        attempts += 1
        if attempts < max_attempts:
            print("Incorrect password. Try again.")

if not success:
    print("Access denied. Too many failed attempts.")

# Pattern 1: Input Validation Loop
def get_positive_number():
    """Get a positive number from user with validation."""
    while True:
        try:
            number = float(input("Enter a positive number: "))
            if number > 0:
                return number
            else:
                print("Please enter a positive number.")
        except ValueError:
            print("Please enter a valid number.")

# Use the validation function
# result = get_positive_number()
# print(f"You entered: {result}")

# Pattern 2: Menu Loop
def show_menu():
    """Display a menu and process user choices."""
    while True:
        print("
=== Main Menu ===")
        print("1. View account")
        print("2. Make deposit")
        print("3. Make withdrawal")
        print("4. Exit")
        
        choice = input("Enter your choice (1-4): ")
        
        if choice == "1":
            print("Displaying account information...")
        elif choice == "2":
            print("Processing deposit...")
        elif choice == "3":
            print("Processing withdrawal...")
        elif choice == "4":
            print("Thank you for using our service!")
            break
        else:
            print("Invalid choice. Please try again.")

# Pattern 3: Search Until Found
def find_item(items, target):
    """Search for an item until found or list exhausted."""
    index = 0
    found = False
    
    while index < len(items) and not found:
        if items[index] == target:
            found = True
            print(f"Found {target} at index {index}")
        else:
            index += 1
    
    if not found:
        print(f"{target} not found in the list")
    
    return found

# Test the search function
numbers = [3, 7, 1, 9, 5, 2, 8]
find_item(numbers, 9)
find_item(numbers, 6)

# Pattern 4: Accumulator with Condition
def sum_until_negative():
    """Sum numbers until a negative number is entered."""
    total = 0
    number = 0
    
    while number >= 0:
        total += number
        try:
            number = float(input("Enter a number (negative to stop): "))
        except ValueError:
            print("Invalid input. Please enter a number.")
            number = 0  # Keep the loop going
    
    print(f"Sum of positive numbers: {total}")
    return total

# Pattern 5: Countdown Loop
def countdown(start):
    """Count down from a starting number."""
    while start > 0:
        print(f"T-minus {start}")
        start -= 1
        # In real code, you might add: time.sleep(1)
    
    print("Blast off!")

countdown(5)

# Pattern 6: Processing Until Empty
def process_queue(queue):
    """Process items from a queue until empty."""
    processed_count = 0
    
    while queue:  # While queue is not empty
        item = queue.pop(0)  # Remove first item
        print(f"Processing: {item}")
        processed_count += 1
    
    print(f"Processed {processed_count} items")
    return processed_count

# Test queue processing
task_queue = ["email", "report", "meeting", "call"]
process_queue(task_queue)

# Pattern 7: Retry Mechanism
def connect_to_server(max_retries=3):
    """Attempt to connect to server with retries."""
    attempts = 0
    connected = False
    
    while attempts < max_retries and not connected:
        attempts += 1
        print(f"Connection attempt {attempts}...")
        
        # Simulate connection attempt (random success/failure)
        import random
        if random.random() > 0.7:  # 30% success rate
            connected = True
            print("Connection successful!")
        else:
            print("Connection failed.")
            if attempts < max_retries:
                print("Retrying...")
    
    if not connected:
        print("Failed to connect after all attempts.")
    
    return connected

# Test connection function
connect_to_server()

# Using break in while loops
def find_first_vowel(text):
    """Find the first vowel in a string."""
    index = 0
    vowels = "aeiouAEIOU"
    
    while index < len(text):
        if text[index] in vowels:
            print(f"First vowel '{text[index]}' found at position {index}")
            break
        index += 1
    else:
        print("No vowels found")

find_first_vowel("Python")
find_first_vowel("rhythm")

# Using continue in while loops
def print_odd_numbers(limit):
    """Print odd numbers up to a limit."""
    number = 1
    
    while number <= limit:
        if number % 2 == 0:
            number += 1
            continue  # Skip even numbers
        
        print(f"Odd number: {number}")
        number += 1

print_odd_numbers(10)

# Complex example with multiple control statements
def process_data_stream():
    """Process a stream of data with various conditions."""
    data_stream = [1, -1, 5, 0, 8, -3, 12, 99, 7, -5]
    index = 0
    processed_count = 0
    error_count = 0
    
    while index < len(data_stream):
        value = data_stream[index]
        
        # Skip negative values
        if value < 0:
            print(f"Skipping negative value: {value}")
            index += 1
            continue
        
        # Stop processing if we hit a special terminator value
        if value == 99:
            print("Terminator value found. Stopping processing.")
            break
        
        # Handle zero values specially
        if value == 0:
            print("Warning: Zero value encountered")
            error_count += 1
            index += 1
            continue
        
        # Process normal positive values
        print(f"Processing value: {value}")
        processed_count += 1
        index += 1
    
    print(f"Summary: Processed {processed_count} values, {error_count} errors")

process_data_stream()

# While loop with else clause
def search_with_else(items, target):
    """Demonstrate while-else clause."""
    index = 0
    
    while index < len(items):
        if items[index] == target:
            print(f"Found {target} at index {index}")
            break
        index += 1
    else:
        # This executes only if the while loop completed normally (no break)
        print(f"{target} not found in the list")

numbers = [1, 3, 5, 7, 9]
search_with_else(numbers, 5)  # Found
search_with_else(numbers, 6)  # Not found

# Nested while loops with control statements
def find_in_matrix(matrix, target):
    """Find a value in a 2D matrix using nested while loops."""
    row = 0
    
    while row < len(matrix):
        col = 0
        
        while col < len(matrix[row]):
            if matrix[row][col] == target:
                print(f"Found {target} at position ({row}, {col})")
                return (row, col)
            col += 1
        
        row += 1
    
    print(f"{target} not found in matrix")
    return None

# Test matrix search
grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

find_in_matrix(grid, 5)
find_in_matrix(grid, 10)

# Common infinite loop mistakes

# Mistake 1: Forgetting to update the condition variable
# count = 1
# while count <= 5:
#     print(f"Count: {count}")
#     # count += 1  # Forgot this line - infinite loop!

# Mistake 2: Incorrect condition logic
# count = 5
# while count >= 1:
#     print(f"Count: {count}")
#     count += 1  # Should be count -= 1

# Mistake 3: Floating point precision issues
# x = 0.1
# while x != 1.0:
#     print(x)
#     x += 0.1  # May never exactly equal 1.0 due to floating point precision

# Correct ways to avoid infinite loops

# 1. Always modify the condition variable
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1  # Always update!

# 2. Use proper comparison operators
total = 0
while total < 100:
    value = 25
    total += value
    print(f"Total: {total}")

# 3. Handle floating point comparisons carefully
x = 0.1
while x < 1.0:  # Use < instead of !=
    print(f"x = {x:.2f}")
    x += 0.1

# 4. Add safety counters for complex conditions
def safe_search(items, target, max_iterations=1000):
    """Search with a safety counter to prevent infinite loops."""
    index = 0
    iterations = 0
    
    while index < len(items) and iterations < max_iterations:
        if items[index] == target:
            return index
        index += 1
        iterations += 1
    
    if iterations >= max_iterations:
        print("Warning: Maximum iterations reached")
    
    return -1  # Not found

# 5. Use break statements for complex exit conditions
def user_input_loop():
    """Safe user input loop with multiple exit conditions."""
    attempts = 0
    max_attempts = 5
    
    while True:
        user_input = input("Enter a number (or 'quit'): ")
        attempts += 1
        
        if user_input.lower() == 'quit':
            print("Goodbye!")
            break
        
        try:
            number = float(user_input)
            print(f"You entered: {number}")
            break
        except ValueError:
            print("Invalid input. Please enter a number or 'quit'.")
        
        # Safety exit
        if attempts >= max_attempts:
            print("Too many invalid attempts. Exiting.")
            break

# Intentional infinite loops (sometimes useful)
def server_loop():
    """Example of an intentional infinite loop for a server."""
    print("Server starting...")
    
    while True:
        # Simulate server operations
        command = input("Enter command (process/stop): ")
        
        if command == "process":
            print("Processing request...")
        elif command == "stop":
            print("Server stopping...")
            break
        else:
            print("Unknown command")

# Testing infinite loop detection
def detect_potential_infinite_loop():
    """Example of adding loop monitoring."""
    count = 0
    loop_iterations = 0
    max_safe_iterations = 1000
    
    while count < 10:
        loop_iterations += 1
        
        # Safety check
        if loop_iterations > max_safe_iterations:
            print("Potential infinite loop detected! Breaking...")
            break
        
        print(f"Iteration {loop_iterations}, count = {count}")
        
        # Simulate a condition that might not update count
        import random
        if random.random() > 0.3:  # 70% chance to increment
            count += 1
    
    print(f"Loop completed after {loop_iterations} iterations")

detect_potential_infinite_loop()

# Best practices to avoid infinite loops
print("
=== Best Practices Summary ===")
print("1. Always modify the loop condition variable")
print("2. Use appropriate comparison operators")
print("3. Add safety counters for complex loops")
print("4. Test loop exit conditions thoroughly")
print("5. Use break statements for multiple exit conditions")
print("6. Be careful with floating-point comparisons")
print("7. Add debugging output to monitor loop progress")

# Example 1: Bank Account System
class BankAccount:
    def __init__(self, initial_balance=0):
        self.balance = initial_balance
        self.transaction_count = 0
    
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            self.transaction_count += 1
            return True
        return False
    
    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            self.transaction_count += 1
            return True
        return False
    
    def get_balance(self):
        return self.balance

def banking_system():
    """Interactive banking system using while loop."""
    account = BankAccount(1000)  # Start with $1000
    
    print("Welcome to Simple Bank!")
    print(f"Your current balance: ${account.get_balance():.2f}")
    
    while True:
        print("\n=== Banking Menu ===")
        print("1. Check balance")
        print("2. Deposit money")
        print("3. Withdraw money")
        print("4. Exit")
        
        choice = input("Choose an option (1-4): ")
        
        if choice == "1":
            print(f"Current balance: ${account.get_balance():.2f}")
        
        elif choice == "2":
            try:
                amount = float(input("Enter deposit amount: $"))
                if account.deposit(amount):
                    print(f"Deposited ${amount:.2f}. New balance: ${account.get_balance():.2f}")
                else:
                    print("Invalid deposit amount.")
            except ValueError:
                print("Please enter a valid amount.")
        
        elif choice == "3":
            try:
                amount = float(input("Enter withdrawal amount: $"))
                if account.withdraw(amount):
                    print(f"Withdrew ${amount:.2f}. New balance: ${account.get_balance():.2f}")
                else:
                    print("Insufficient funds or invalid amount.")
            except ValueError:
                print("Please enter a valid amount.")
        
        elif choice == "4":
            print(f"Thank you! Final balance: ${account.get_balance():.2f}")
            print(f"Total transactions: {account.transaction_count}")
            break
        
        else:
            print("Invalid choice. Please try again.")

# Example 2: Number Guessing Game
def number_guessing_game():
    """Number guessing game with while loop."""
    import random
    
    secret_number = random.randint(1, 100)
    attempts = 0
    max_attempts = 7
    
    print("=== Number Guessing Game ===")
    print("I&apos;m thinking of a number between 1 and 100.")
    print(f"You have {max_attempts} attempts to guess it!")
    
    while attempts < max_attempts:
        try:
            guess = int(input(f"\nAttempt {attempts + 1}: Enter your guess: "))
            attempts += 1
            
            if guess < 1 or guess > 100:
                print("Please guess a number between 1 and 100.")
                continue
            
            if guess == secret_number:
                print(f"Congratulations! You guessed it in {attempts} attempts!")
                return True
            elif guess < secret_number:
                print("Too low!")
            else:
                print("Too high!")
            
            remaining = max_attempts - attempts
            if remaining > 0:
                print(f"You have {remaining} attempts left.")
        
        except ValueError:
            print("Please enter a valid number.")
            # Don&apos;t count invalid input as an attempt
            attempts -= 1
    
    print(f"\nGame over! The number was {secret_number}.")
    return False

# When to use WHILE loops vs FOR loops

print("=== WHILE LOOPS - Best for: ===")
print("1. Unknown number of iterations")
print("2. Condition-based repetition")
print("3. User input validation")
print("4. Event-driven loops")
print("5. Search until found scenarios")

print("
=== FOR LOOPS - Best for: ===")
print("1. Known sequences/collections")
print("2. Fixed number of iterations")
print("3. Processing lists, strings, ranges")
print("4. Mathematical iterations")
print("5. Data transformation tasks")

# Example 1: User input - WHILE is better
def get_valid_password():
    """WHILE loop is perfect for input validation."""
    while True:
        password = input("Enter password (min 8 chars): ")
        if len(password) >= 8:
            return password
        print("Password too short. Try again.")

# Trying to do the same with FOR would be awkward:
def get_valid_password_for():
    """FOR loop approach - not ideal for this task."""
    max_attempts = 10  # Arbitrary limit
    for attempt in range(max_attempts):
        password = input(f"Enter password (attempt {attempt + 1}): ")
        if len(password) >= 8:
            return password
        print("Password too short. Try again.")
    return None  # Failed after max attempts

# Example 2: Processing a list - FOR is better
def process_scores_for(scores):
    """FOR loop is perfect for known collections."""
    total = 0
    for score in scores:
        total += score
    return total / len(scores) if scores else 0

# WHILE version is unnecessarily complex:
def process_scores_while(scores):
    """WHILE loop approach - overly complex for this task."""
    total = 0
    index = 0
    while index < len(scores):
        total += scores[index]
        index += 1
    return total / len(scores) if scores else 0

# Example 3: Search until found - WHILE is better
def find_first_prime_while(start):
    """Find first prime number starting from a value."""
    number = start
    while True:
        if is_prime(number):
            return number
        number += 1

def is_prime(n):
    """Check if a number is prime."""
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

# Example 4: Fixed iterations - FOR is better
def print_multiplication_table_for(n):
    """FOR loop is perfect for known ranges."""
    for i in range(1, 11):
        print(f"{n} x {i} = {n * i}")

# WHILE version requires manual counter management:
def print_multiplication_table_while(n):
    """WHILE loop approach - unnecessary complexity."""
    i = 1
    while i <= 10:
        print(f"{n} x {i} = {n * i}")
        i += 1

# Example 5: Event simulation - WHILE is better
def simulate_dice_game():
    """Simulate rolling dice until double sixes."""
    import random
    
    rolls = 0
    while True:
        rolls += 1
        die1 = random.randint(1, 6)
        die2 = random.randint(1, 6)
        print(f"Roll {rolls}: {die1}, {die2}")
        
        if die1 == 6 and die2 == 6:
            print(f"Double sixes! It took {rolls} rolls.")
            break

# Example 6: String processing - both can work
def count_vowels_for(text):
    """FOR loop - natural for iterating through strings."""
    count = 0
    vowels = "aeiouAEIOU"
    for char in text:
        if char in vowels:
            count += 1
    return count

def count_vowels_while(text):
    """WHILE loop - works but less Pythonic."""
    count = 0
    index = 0
    vowels = "aeiouAEIOU"
    while index < len(text):
        if text[index] in vowels:
            count += 1
        index += 1
    return count

# Decision matrix for choosing loop type
def choose_loop_type():
    """Guidelines for choosing between while and for loops."""
    
    questions = [
        "Do you know the exact sequence to iterate over?",
        "Is the number of iterations fixed?",
        "Are you processing a collection (list, string, etc.)?",
        "Is this a mathematical iteration (range of numbers)?",
    ]
    
    for_answers = 0
    
    print("=== Loop Type Decision Helper ===")
    for question in questions:
        answer = input(f"{question} (yes/no): ").lower()
        if answer in ['yes', 'y']:
            for_answers += 1
    
    if for_answers >= 3:
        print("
Recommendation: Use a FOR loop")
        print("- You have a known sequence or collection")
        print("- The iteration count is predictable")
    elif for_answers <= 1:
        print("
Recommendation: Use a WHILE loop")
        print("- The iteration depends on conditions")
        print("- You don&apos;t know how many iterations you need")
    else:
        print("
Recommendation: Either loop type could work")
        print("- Consider which feels more natural")
        print("- FOR is generally preferred when both work")

# Performance comparison (generally negligible difference)
def performance_comparison():
    """Compare performance of while vs for loops."""
    import time
    
    # Large number for testing
    n = 1000000
    
    # FOR loop timing
    start_time = time.time()
    total_for = 0
    for i in range(n):
        total_for += i
    for_time = time.time() - start_time
    
    # WHILE loop timing
    start_time = time.time()
    total_while = 0
    i = 0
    while i < n:
        total_while += i
        i += 1
    while_time = time.time() - start_time
    
    print(f"FOR loop time: {for_time:.4f} seconds")
    print(f"WHILE loop time: {while_time:.4f} seconds")
    print(f"Results equal: {total_for == total_while}")
    print("
Note: Performance difference is usually negligible.")
    print("Choose based on readability and appropriateness, not speed.")

# Summary of best practices
print("
=== Summary: When to Use Each Loop Type ===")
print("
Use WHILE loops when:")
print("- You don&apos;t know how many iterations you need")
print("- The loop depends on a changing condition")
print("- You&apos;re waiting for user input or events")
print("- You&apos;re implementing search algorithms")
print("- You need to retry operations")

print("
Use FOR loops when:")
print("- You&apos;re iterating over a known collection")
print("- You need a specific number of iterations")
print("- You&apos;re processing lists, strings, or ranges")
print("- You&apos;re doing mathematical iterations")
print("- You want cleaner, more readable code")

# Test some functions
print(f"
Testing: First prime after 20: {find_first_prime_while(20)}")
print(f"Vowel count in 'Python': {count_vowels_for('Python')}")

# Uncomment to run interactive examples:
// choose_loop_type()
// performance_comparison()