nucleoWhisper/nuxt4/app/composables/useFrigateEvents.ts

/**
 * Composable para gestionar eventos de Frigate
 * API: https://camaras.nucleoriofrio.com/api/events/{camera}/create
 */

export interface FrigateEventParams {
  label: string
  sub_label?: string
  duration?: number
  include_recording?: boolean
  draw?: {
    boxes?: Array<{
      box: [number, number, number, number]
      color?: [number, number, number]
      score?: number
    }>
  }
}

export interface FrigateEventResponse {
  success: boolean
  event_id?: string
  message?: string
}

export const useFrigateEvents = () => {
  const BASE_URL = 'https://camaras.nucleoriofrio.com'

  const isCreating = useState<boolean>('frigate_creating', () => false)
  const error = useState<string | null>('frigate_error', () => null)
  const lastEventId = useState<string | null>('frigate_last_event', () => null)

  /**
   * Crea un evento en Frigate para una camara especifica
   */
  const createEvent = async (
    camera: string,
    params: FrigateEventParams
  ): Promise<FrigateEventResponse> => {
    isCreating.value = true
    error.value = null

    try {
      // Extraer el nombre base de la camara (sin _main o _sub)
      const cameraName = camera.replace(/_main$|_sub$/, '')

      const response = await $fetch<FrigateEventResponse>(
        `${BASE_URL}/api/events/${cameraName}/create`,
        {
          method: 'POST',
          credentials: 'include',
          body: params
        }
      )

      if (response.event_id) {
        lastEventId.value = response.event_id
      }

      return { success: true, ...response }
    } catch (err: unknown) {
      const errorMessage = (err as Error)?.message || 'Error al crear evento'
      error.value = errorMessage
      console.error('[Frigate] Error creating event:', err)
      return { success: false, message: errorMessage }
    } finally {
      isCreating.value = false
    }
  }

  /**
   * Crea un evento rapido "eventoWhisper" de 1 minuto
   */
  const createQuickEvent = async (camera: string): Promise<FrigateEventResponse> => {
    return createEvent(camera, {
      label: 'eventoWhisper',
      duration: 60,
      include_recording: true
    })
  }

  /**
   * Limpia el error
   */
  const clearError = () => {
    error.value = null
  }

  return {
    isCreating: readonly(isCreating),
    error: readonly(error),
    lastEventId: readonly(lastEventId),
    createEvent,
    createQuickEvent,
    clearError
  }
}