# pip install opencv-contrib-python
# Comando para instalar las librerías necesarias de visión por computadora

import threading
# Importamos threading para leer la cámara en segundo plano
import time
# Importamos time para medir cuánto tiempo pasa sin recibir imágenes
import cv2
# Importamos la librería OpenCV, que nos permite trabajar con imágenes y video

# ===== CONFIGURA AQUÍ TU CÁMARA =====
IP = '192.168.137.49'   # dirección IP que muestra la aplicación del celular
PUERTO = 8080           # 8080 en IP Webcam (Android), 8081 en IP Camera Lite (iPhone/iPad)
IPHONE = False          # True si usas IP Camera Lite (iPhone/iPad), False si usas IP Webcam (Android)
# ====================================

# Cada aplicación usa un formato de dirección distinto. Usamos el video por HTTP
# porque tiene mucho menos retardo que RTSP (medido: ~150 ms contra 0.4–1.2 s).
if IPHONE:
    url = f'http://admin:admin@{IP}:{PUERTO}/'
else:
    url = f'http://{IP}:{PUERTO}/video'


class CamaraUltimoFrame:
    """Lee la cámara en segundo plano y entrega siempre la imagen más reciente.

    Un hilo lee las imágenes apenas llegan y solo guarda la última. Así el
    programa principal nunca espera ni procesa imágenes viejas acumuladas.
    """

    def __init__(self, url):
        self.cap = cv2.VideoCapture(url)
        self.frame = None              # la imagen más reciente
        self.t_ultimo = time.time()    # cuándo llegó la última imagen
        self.activa = self.cap.isOpened()
        self.hilo = threading.Thread(target=self._leer, daemon=True)
        self.hilo.start()

    def _leer(self):
        # Este ciclo corre en paralelo con el programa principal
        while self.activa:
            ret, frame = self.cap.read()
            if ret:
                self.frame = frame
                self.t_ultimo = time.time()

    def leer(self):
        # Devuelve una copia de la última imagen recibida (None si aún no ha llegado ninguna).
        # Es una copia para que dibujar sobre ella no altere la imagen guardada.
        return None if self.frame is None else self.frame.copy()

    def cerrar(self):
        self.activa = False
        self.hilo.join(timeout=2)      # esperamos a que el hilo termine de leer
        self.cap.release()             # antes de soltar la cámara


print("Conectando a", url)
camara = CamaraUltimoFrame(url)
# Creamos la cámara: abre la conexión y empieza a leer en segundo plano

if not camara.activa:
    print("No se pudo abrir la cámara: revise la IP, el puerto y que el servidor de la aplicación esté encendido")
else:
    # Iniciamos un bucle que muestra siempre la imagen más reciente
    while True:
        frame = camara.leer()

        if frame is not None:
            # Mostramos el frame en una ventana llamada 'temp'
            # cv2.resize() redimensiona la imagen a 640x480 píxeles
            cv2.imshow('temp', cv2.resize(frame, (640, 480)))

        # Si pasan 5 segundos sin recibir imágenes, la transmisión se cortó
        if time.time() - camara.t_ultimo > 5:
            print("Stream ended...")
            break

        # Capturamos la entrada del teclado (espera 1ms por cada iteración)
        key = cv2.waitKey(1)
        # Si presionamos 'q', salimos del bucle
        if key == ord('q'):
            break

# Cerramos la cámara y el hilo que la lee
camara.cerrar()
# Cerramos todas las ventanas creadas por OpenCV
cv2.destroyAllWindows()