from PySide6.QtCore import QObject, Signal
from PySide6.QtGui import QPixmap

from .camera_controller import CameraController
from .gphoto_camera import GPhotoCamera
from .opencv_camera import OpenCvCamera
from .base_camera import BaseCamera


class CameraManager(QObject):
	"""
	Zarządza wszystkimi operacjami związanymi z kamerami,
	stanowiąc fasadę dla reszty aplikacji.
	"""
	frame_ready = Signal(QPixmap)
	error_occurred = Signal(str)
	cameras_detected = Signal(list)
	camera_started = Signal()
	camera_stopped = Signal()

	def __init__(self, parent: QObject | None = None) -> None:
		super().__init__(parent)
		self._camera_controller = CameraController()
		self._detected_cameras: list[dict] = []
		self._active_camera: BaseCamera | None = None
		self._active_camera_info: dict | None = None

		# Przekazywanie sygnałów z kontrolera kamery na zewnątrz
		self._camera_controller.frame_ready.connect(self.frame_ready)
		self._camera_controller.error_occurred.connect(self.error_occurred)
		self._camera_controller.camera_ready.connect(self.start_liveview)

	def detect_cameras(self) -> None:
		"""Wykrywa wszystkie dostępne kamery (GPhoto i OpenCV)."""
		self._detected_cameras.clear()

		# Wykryj kamery GPhoto
		try:
			gphoto_cameras = GPhotoCamera.detect()
			for index, info in gphoto_cameras.items():
				self._detected_cameras.append({
					"id": f"gphoto_{index}",
					"name": f"{info['name']} ({info['port']})",
					"type": "gphoto",
					"index": index
				})
		except Exception as e:
			self.error_occurred.emit(
				f"Błąd podczas wykrywania kamer GPhoto: {e}")

		# Wykryj kamery OpenCV
		try:
			opencv_cameras = OpenCvCamera.detect()
			for index, info in opencv_cameras.items():
				self._detected_cameras.append({
					"id": f"opencv_{index}",
					"name": f"OpenCV: {info['name']}",
					"type": "opencv",
					"index": index
				})
		except Exception as e:
			self.error_occurred.emit(
				f"Błąd podczas wykrywania kamer OpenCV: {e}")

		self.cameras_detected.emit(self._detected_cameras)

	def get_detected_cameras(self) -> list[dict]:
		return self._detected_cameras

	def start_camera(self, camera_id: str, fps: int = 15) -> None:
		"""Uruchamia wybraną kamerę."""
		if self._active_camera:
			self.stop_camera()

		camera_info = next(
			(c for c in self._detected_cameras if c['id'] == camera_id), None)

		if not camera_info:
			self.error_occurred.emit(
				f"Nie znaleziono kamery o ID: {camera_id}")
			return

		camera_type = camera_info['type']
		camera_index = camera_info['index']

		if camera_type == "gphoto":
			self._active_camera = GPhotoCamera()
		elif camera_type == "opencv":
			self._active_camera = OpenCvCamera()
		else:
			self.error_occurred.emit(f"Nieznany typ kamery: {camera_type}")
			return

		self._active_camera_info = camera_info

		self._camera_controller.set_camera(self._active_camera, fps)
		self._camera_controller.start_camera()

	def start_liveview(self, connected):
		if connected:
			self._camera_controller.start_stream()
			self.camera_started.emit()
		else:
			self._active_camera = None
			self._active_camera_info = None

	def stop_camera(self) -> None:
		"""Zatrzymuje aktywną kamerę."""
		if self._active_camera:
			self._camera_controller.stop_camera()
			self._active_camera = None
			self._active_camera_info = None
			self.camera_stopped.emit()

	def get_active_camera_info(self) -> dict | None:
		return self._active_camera_info

	def rotate_left(self):
		self._camera_controller.rotate_left()

	def rotate_right(self):
		self._camera_controller.rotate_right()

	def shutdown(self) -> None:
		"""Zamyka kontroler kamery i jego wątek."""
		self.stop_camera()
		self._camera_controller.stop()