code_active.py

# requirements:
#   pip install pygame pyttsx3

import os
import subprocess
# os.environ.setdefault("SDL_AUDIODRIVER", "dummy")  # keep pygame off the audio device

import sys
import threading
import queue
import time
import pygame
import pyttsx3
from typing import Optional

# -----------------------------
# Config (tweak as you like)
# -----------------------------
WINDOWED_SIZE = (800, 600)
DOT_RADIUS = 30
DOT_THICKNESS = 0
BG_COLOR = (0, 0, 0)
DOT_COLOR = (255, 255, 255)
TARGET_FPS = 120
FULLSCREEN = False
MONITOR_INDEX = 0
TTS_RATE = 170
TTS_VOLUME = 1.0
INPUT_HOTKEY = pygame.K_1  # '1' enters typing mode
EXIT_TYPING_KEY = pygame.K_2  # '2' exits typing mode (cancel)
QUIT_KEY = pygame.K_q  # 'q' quits the app
FONT_SIZE = 28
OVERLAY_BG = (0, 0, 0)
OVERLAY_FG = (255, 255, 255)
OVERLAY_ALPHA = 200
PADDING = 16
TYPING_TEXT_COLOR = (20, 20, 20)  # <-- NEW: almost black
# -----------------------------

def create_display(fullscreen: bool, monitor_index: int):
    pygame.display.init()
    if fullscreen:
        flags = pygame.FULLSCREEN
        try:
            return pygame.display.set_mode((0, 0), flags, display=monitor_index)
        except TypeError:
            sizes = pygame.display.get_desktop_sizes()
            if monitor_index < 0 or monitor_index >= len(sizes):
                monitor_index = 0
            x_offset = sum(w for (w, h) in sizes[:monitor_index])
            os.environ["SDL_VIDEO_WINDOW_POS"] = f"{x_offset},0"
            pygame.display.quit(); pygame.display.init()
            return pygame.display.set_mode(sizes[monitor_index], pygame.NOFRAME)
    else:
        return pygame.display.set_mode(WINDOWED_SIZE)


def humanize_key_name(name: str) -> str:
    """Make pygame key names sound nicer when spoken."""
    mapping = {
        "left": "Make sure to put the right sides together",
        "right": "The feet need to face inward",
        "g": "The feet should be placed between the fabric",
        "down": "Make sure not to add pins all the way",
        "return": "Do not cut the thread too short",
        "backspace": "Rest assured, I am here to help you",
        "tab": "Are you okay?",
        "space": "Do you need help?",
        "s": "Should I call a human for assistance?",
        "w": "Try to sew in a straight line",
        "e": "The washer for the eye should be on the inside",
        "r": "Hello! I am your smart sewing machine.",
        "t": "What are we making today?",
        "y": "This is my working area.",
        "u": "Goodbye!",   
        "i": "That is right.",
        "o": "Uh-oh.",
        "p": "I believe in you!",    
        "a": "Yes.",
        "z": "No.",
        "x": "You seem to have a sheet with instructions.",         
        "caps lock": "Make sure to push the filling inward before pinning the final edge",
        "left shift": "You are forgetting a step",
        "right shift": "You are doing it correctly",
    }
    # Function keys like f1..f24 already okay, keep as-is
    return mapping.get(name, name)

def tts_worker(q: "queue.Queue[str]"):
    try:
        while True:
            text = q.get()
            if text is None:
                break
            try:
                # macOS 'say' fallback; replace with pyttsx3 if preferred
                subprocess.run(['say', '-r', str(TTS_RATE), text], check=True)
            except Exception as e:
                print(f"TTS error: {e}")
    except Exception:
        pass

def draw_input_overlay(screen: pygame.Surface, font: pygame.font.Font, buffer: str, prompt: Optional[str] = None):
    w, h = screen.get_size()
    panel_w = min(int(w * 0.9), 1000)
    panel_h = 130
    panel_x = (w - panel_w) // 2
    panel_y = h - panel_h - 40

    overlay = pygame.Surface((panel_w, panel_h), pygame.SRCALPHA)
    overlay.fill((*OVERLAY_BG, OVERLAY_ALPHA))

    lines = []
    if prompt:
        lines.append(prompt)
    lines.append(buffer if buffer else "")

    y = PADDING
    for line in lines:
        surf = font.render(line, True, TYPING_TEXT_COLOR)
        overlay.blit(surf, (PADDING, y))
        y += surf.get_height() + 8

    screen.blit(overlay, (panel_x, panel_y))

def main():
    screen = create_display(FULLSCREEN, MONITOR_INDEX)
    pygame.font.init()
    font = pygame.font.Font(None, FONT_SIZE)
    pygame.mouse.set_visible(False)

    # Optional: ensure key repeat is off (it is by default, but harmless)
    try:
        pygame.key.set_repeat(0)
    except Exception:
        pass

    tts_queue: "queue.Queue[str]" = queue.Queue()
    tts_thread = threading.Thread(target=tts_worker, args=(tts_queue,), daemon=True)
    tts_thread.start()

    clock = pygame.time.Clock()
    running = True
    input_mode = False
    input_buffer = ""
    last_spoken: Optional[str] = None  # remembers last thing that was spoken

    def start_text_input():
        try:
            pygame.key.start_text_input()
        except Exception:
            pass

    def stop_text_input():
        try:
            pygame.key.stop_text_input()
        except Exception:
            pass

    try:
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False

                elif event.type == pygame.KEYDOWN:
                    # Global quit with 'q'
                    if event.key == QUIT_KEY:
                        running = False
                        break

                    if input_mode:
                        # CONTROL KEYS ONLY while typing
                        if event.key in (EXIT_TYPING_KEY, pygame.K_ESCAPE):
                            input_buffer = ""
                            input_mode = False
                            stop_text_input()
                        elif event.key == pygame.K_RETURN:
                            text = input_buffer.strip()
                            if text:
                                print(f"TTS (typed): {text}")
                                tts_queue.put(text)
                                last_spoken = text  # remember typed message
                            input_buffer = ""
                            input_mode = False
                            stop_text_input()
                        elif event.key == pygame.K_BACKSPACE:
                            input_buffer = input_buffer[:-1]
                        # IMPORTANT: do NOT append event.unicode here.
                    else:
                        # Up arrow repeats the last spoken phrase
                        if event.key == pygame.K_UP:
                            if last_spoken:
                                print(f"Repeat: {last_spoken}")
                                tts_queue.put(last_spoken)
                            # do not fall through; Up only repeats
                        # Enter typing mode with '1'
                        elif event.key == INPUT_HOTKEY:
                            input_mode = True
                            input_buffer = ""
                            start_text_input()
                        else:
                            key_name = pygame.key.name(event.key)
                            readable = humanize_key_name(key_name)
                            print(f"User pressed {readable}")
                            tts_queue.put(readable)
                            last_spoken = readable  # remember mapped speech

                # Use TEXTINPUT exclusively for characters
                elif event.type == pygame.TEXTINPUT and input_mode:
                    if event.text:
                        input_buffer += event.text

            screen.fill(BG_COLOR)
            mx, my = pygame.mouse.get_pos()
            pygame.draw.circle(screen, DOT_COLOR, (mx, my), DOT_RADIUS, DOT_THICKNESS)

            if input_mode:
                draw_input_overlay(
                    screen, font, input_buffer,
                    prompt="Typing mode (started with '1'). Enter: speak · '2' or Esc: exit typing · 'q': quit app"
                )

            pygame.display.flip()
            clock.tick(TARGET_FPS)
    finally:
        tts_queue.put(None)
        tts_thread.join(timeout=2.0)
        pygame.quit()
        sys.exit()

if __name__ == "__main__":
    main()