import numpy as np


def text_to_bits(text, alphabet):
    """Convert text to binary bits based on alphabet indexing."""
    char_to_idx = {char: idx for idx, char in enumerate(alphabet)}
    bits = []
    for char in text:
        idx = char_to_idx[char]
        # Convert index to 6-bit binary string, padded with zeros
        bits.extend([int(b) for b in format(idx, '06b')])
    return np.array(bits)


def transmitter(text):
    """
    Convert a 40-character text message to a signal vector x.

    Parameters:
    text (str): Input text of 40 characters from the given alphabet.

    Returns:
    np.ndarray: Signal vector x of length 480 with energy <= 2000.
    """
    # Define the alphabet
    alphabet = (
        'abcdefghijklmnopqrstuvwxyz'
        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
        '0123456789 .'
    )

    # Input validation
    if len(text) != 40 or not all(c in alphabet for c in text):
        raise ValueError("Text must be 40 characters from the given alphabet.")

    # Convert text to 240 bits (40 chars * 6 bits/char)
    bits = text_to_bits(text, alphabet)

    # BPSK modulation: 0 -> +sqrt(E), 1 -> -sqrt(E)
    E = 4  # Energy per bit
    symbols = np.sqrt(E) * (1 - 2 * bits)  # Map 0 to +sqrt(E), 1 to -sqrt(E)

    # Create signal x: each bit is sent twice (odd and even indices)
    n = 480  # Block length
    x = np.zeros(n)
    for i in range(240):
        x[2 * i] = symbols[i]  # Even index (2i)
        x[2 * i + 1] = symbols[i]  # Odd index (2i+1)

    # Verify energy constraint
    energy = np.sum(x ** 2)
    if energy > 2000:
        raise ValueError(f"Signal energy {energy} exceeds limit of 2000.")

    return x