import { beforeEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CameraManagerEngine } from '../../../src/camera-manager/engine';
import { FrigateCamera } from '../../../src/camera-manager/frigate/camera';
import { getPTZInfo } from '../../../src/camera-manager/frigate/requests';
import {
  FrigateEventChange,
  FrigateEventChangeTriggerResponse,
  FrigateEventChangeType,
} from '../../../src/camera-manager/frigate/types';
import { CameraTriggerEventType } from '../../../src/config/types';
import { EntityRegistryManager } from '../../../src/utils/ha/entity-registry';
import { Entity } from '../../../src/utils/ha/entity-registry/types';
import {
  callHASubscribeMessageHandler,
  createCameraConfig,
  createHASS,
  createRegistryEntity,
} from '../../test-utils';

vi.mock('../../../src/camera-manager/frigate/requests');

const createFrigateEventChangeTrigger = (
  type: FrigateEventChangeType,
  before: FrigateEventChange,
  after: FrigateEventChange,
): FrigateEventChangeTriggerResponse => {
  return {
    variables: {
      trigger: {
        payload_json: {
          before: before,
          after: after,
          type: type,
        },
      },
    },
  };
};

describe('FrigateCamera', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    vi.mocked(getPTZInfo).mockResolvedValue({});
  });

  describe('should initialize config', () => {
    describe('should detect camera name', () => {
      it('without a camera_entity', async () => {
        const config = createCameraConfig();
        const camera = new FrigateCamera(config, mock<CameraManagerEngine>());
        const beforeConfig = { ...config };

        await camera.initialize(createHASS(), mock<EntityRegistryManager>());

        expect(beforeConfig).toEqual(camera.getConfig());
      });

      it('with a missing camera_entity', async () => {
        const camera = new FrigateCamera(
          createCameraConfig({
            camera_entity: 'camera.not_here',
          }),
          mock<CameraManagerEngine>(),
        );
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockRejectedValue(null);

        expect(
          async () => await camera.initialize(createHASS(), entityRegistryManager),
        ).rejects.toThrowError(/Could not find camera entity/);
      });

      it('with a valid camera_entity', async () => {
        const camera = new FrigateCamera(
          createCameraConfig({
            camera_entity: 'camera.front_door',
          }),
          mock<CameraManagerEngine>(),
        );
        const entityRegistryManager = mock<EntityRegistryManager>();
        const entity = createRegistryEntity({
          unique_id: '8c4e19d258359e82bc0cf9d47b021c46:camera:fnt_dr',
          platform: 'frigate',
        });
        entityRegistryManager.getEntity.mockResolvedValue(entity);

        await camera.initialize(createHASS(), entityRegistryManager);

        expect(camera.getConfig().frigate.camera_name).toBe('fnt_dr');
      });

      it('with a camera_entity without camera_name match', async () => {
        const camera = new FrigateCamera(
          createCameraConfig({
            camera_entity: 'camera.front_door',
          }),
          mock<CameraManagerEngine>(),
        );
        const entityRegistryManager = mock<EntityRegistryManager>();
        const entity = createRegistryEntity({
          unique_id: '8c4e19d258359e82bc0cf9d47b021c46:WRONG:fnt_dr',
          platform: 'frigate',
        });
        entityRegistryManager.getEntity.mockResolvedValue(entity);

        await camera.initialize(createHASS(), entityRegistryManager);

        expect(camera.getConfig().frigate.camera_name).toBeUndefined();
      });

      it('with a camera_entity without platform match', async () => {
        const camera = new FrigateCamera(
          createCameraConfig({
            camera_entity: 'camera.front_door',
          }),
          mock<CameraManagerEngine>(),
        );
        const entityRegistryManager = mock<EntityRegistryManager>();
        const entity = createRegistryEntity({
          unique_id: '8c4e19d258359e82bc0cf9d47b021c46:camera:fnt_dr',
          platform: 'something_else',
        });
        entityRegistryManager.getEntity.mockResolvedValue(entity);

        await camera.initialize(createHASS(), entityRegistryManager);

        expect(camera.getConfig().frigate.camera_name).toBeUndefined();
      });
    });
  });

  describe('should detect capabilities', () => {
    it('basic non-birdseye', async () => {
      const camera = new FrigateCamera(
        createCameraConfig({
          frigate: {
            camera_name: 'front_door',
          },
        }),
        mock<CameraManagerEngine>(),
      );

      await camera.initialize(createHASS(), mock<EntityRegistryManager>());

      expect(camera.getCapabilities()?.has('favorite-events')).toBeTruthy();
      expect(camera.getCapabilities()?.has('favorite-recordings')).toBeFalsy();
      expect(camera.getCapabilities()?.has('seek')).toBeTruthy();
      expect(camera.getCapabilities()?.has('clips')).toBeTruthy();
      expect(camera.getCapabilities()?.has('live')).toBeTruthy();
      expect(camera.getCapabilities()?.has('snapshots')).toBeTruthy();
      expect(camera.getCapabilities()?.has('recordings')).toBeTruthy();
      expect(vi.mocked(getPTZInfo)).toBeCalled();
    });

    it('basic birdseye', async () => {
      const camera = new FrigateCamera(
        createCameraConfig({
          frigate: {
            camera_name: 'birdseye',
          },
        }),
        mock<CameraManagerEngine>(),
      );

      await camera.initialize(createHASS(), mock<EntityRegistryManager>());

      expect(camera.getCapabilities()?.has('favorite-events')).toBeFalsy();
      expect(camera.getCapabilities()?.has('favorite-recordings')).toBeFalsy();
      expect(camera.getCapabilities()?.has('seek')).toBeFalsy();
      expect(camera.getCapabilities()?.has('clips')).toBeFalsy();
      expect(camera.getCapabilities()?.has('live')).toBeTruthy();
      expect(camera.getCapabilities()?.has('snapshots')).toBeFalsy();
      expect(camera.getCapabilities()?.has('recordings')).toBeFalsy();
      expect(vi.mocked(getPTZInfo)).not.toBeCalled();
    });

    describe('with ptz', () => {
      it('when getPTZInfo call fails', async () => {
        const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);

        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
          }),
          mock<CameraManagerEngine>(),
        );
        vi.mocked(getPTZInfo).mockRejectedValue(new Error());
        await camera.initialize(createHASS(), mock<EntityRegistryManager>());

        expect(camera.getCapabilities()?.has('ptz')).toBeFalsy();
        expect(consoleSpy).toBeCalled();
      });

      it('when getPTZInfo call succeeds with continuous motion', async () => {
        vi.spyOn(global.console, 'warn').mockReturnValue(undefined);

        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
          }),
          mock<CameraManagerEngine>(),
        );
        vi.mocked(getPTZInfo).mockResolvedValue({
          features: ['pt', 'zoom'],
          name: 'front_door',
          presets: ['preset01'],
        });
        await camera.initialize(createHASS(), mock<EntityRegistryManager>());

        expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
        expect(camera.getCapabilities()?.getPTZCapabilities()).toEqual({
          panTilt: ['continuous'],
          zoom: ['continuous'],
          presets: ['preset01'],
        });
      });

      it('when getPTZInfo call succeeds with relative motion', async () => {
        vi.spyOn(global.console, 'warn').mockReturnValue(undefined);

        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
          }),
          mock<CameraManagerEngine>(),
        );
        vi.mocked(getPTZInfo).mockResolvedValue({
          features: ['pt-r', 'zoom-r'],
          name: 'front_door',
          presets: ['preset01'],
        });
        await camera.initialize(createHASS(), mock<EntityRegistryManager>());

        expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
        expect(camera.getCapabilities()?.getPTZCapabilities()).toEqual({
          panTilt: ['relative'],
          zoom: ['relative'],
          presets: ['preset01'],
        });
      });
    });
  });

  describe('should handle events', () => {
    it('should subscribe', async () => {
      const camera = new FrigateCamera(
        createCameraConfig({
          frigate: {
            client_id: 'CLIENT_ID',
            camera_name: 'CAMERA',
          },
        }),
        mock<CameraManagerEngine>(),
      );
      const hass = createHASS();

      await camera.initialize(hass, mock<EntityRegistryManager>());

      expect(hass.connection.subscribeMessage).toBeCalledWith(expect.anything(), {
        type: 'subscribe_trigger',
        trigger: {
          platform: 'mqtt',
          topic: `CLIENT_ID/events`,
          payload: 'CAMERA',
          value_template: '{{ value_json.after.camera }}',
        },
      });
    });

    it('should not subscribe with no trigger events', async () => {
      const camera = new FrigateCamera(
        createCameraConfig({
          frigate: {
            client_id: 'CLIENT_ID',
            camera_name: 'CAMERA',
          },
          triggers: {
            events: [],
          },
        }),
        mock<CameraManagerEngine>(),
      );
      const hass = createHASS();

      await camera.initialize(hass, mock<EntityRegistryManager>());

      expect(hass.connection.subscribeMessage).not.toBeCalled();
    });

    it('should not subscribe with no camera name', async () => {
      const camera = new FrigateCamera(
        createCameraConfig({
          frigate: {
            client_id: 'CLIENT_ID',
          },
        }),
        mock<CameraManagerEngine>(),
      );
      const hass = createHASS();

      await camera.initialize(hass, mock<EntityRegistryManager>());

      expect(hass.connection.subscribeMessage).not.toBeCalled();
    });

    it('should unsubscribe on destroy', async () => {
      const camera = new FrigateCamera(
        createCameraConfig({
          frigate: { camera_name: 'front_door' },
        }),
        mock<CameraManagerEngine>(),
      );
      const hass = createHASS();
      const unsubscribeCallback = vi.fn();
      vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubscribeCallback);

      await camera.initialize(hass, mock<EntityRegistryManager>());
      expect(unsubscribeCallback).not.toBeCalled();

      await camera.destroy();
      expect(unsubscribeCallback).toBeCalled();
    });

    describe('should call handler correctly', () => {
      it('with malformed Frigate event', async () => {
        const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);

        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: { camera_name: 'front_door' },
          }),
          mock<CameraManagerEngine>(),
        );

        const hass = createHASS();
        await camera.initialize(hass, mock<EntityRegistryManager>());

        callHASubscribeMessageHandler(hass, 'GARBAGE');

        expect(consoleSpy).toBeCalledWith(
          'Ignoring unparseable Frigate event',
          'GARBAGE',
        );
      });

      it('with wrong camera', async () => {
        const eventCallback = vi.fn();
        const camera = new FrigateCamera(
          createCameraConfig({
            id: 'CAMERA_1',
            frigate: {
              camera_name: 'camera.front_door',
            },
          }),
          mock<CameraManagerEngine>(),
          {
            eventCallback: eventCallback,
          },
        );

        const hass = createHASS();
        await camera.initialize(hass, mock<EntityRegistryManager>());

        callHASubscribeMessageHandler(
          hass,
          createFrigateEventChangeTrigger(
            'new',
            {
              camera: 'camera.back_door',
              snapshot: null,
              has_clip: false,
              has_snapshot: false,
              label: 'person',
              current_zones: [],
            },
            {
              camera: 'camera.back_door',
              snapshot: null,
              has_clip: false,
              has_snapshot: true,
              label: 'person',
              current_zones: [],
            },
          ),
        );

        expect(eventCallback).not.toBeCalled();
      });

      describe('should handle event type correctly', () => {
        it.each([
          [
            ['events' as const, 'snapshots' as const, 'clips' as const],
            false,
            false,
            true,
          ],
          [
            ['events' as const, 'snapshots' as const, 'clips' as const],
            false,
            true,
            true,
          ],
          [
            ['events' as const, 'snapshots' as const, 'clips' as const],
            true,
            false,
            true,
          ],
          [
            ['events' as const, 'snapshots' as const, 'clips' as const],
            true,
            true,
            true,
          ],

          [['events' as const, 'snapshots' as const], false, false, true],
          [['events' as const, 'snapshots' as const], false, true, true],
          [['events' as const, 'snapshots' as const], true, false, true],
          [['events' as const, 'snapshots' as const], true, true, true],

          [['events' as const, 'clips' as const], false, false, true],
          [['events' as const, 'clips' as const], false, true, true],
          [['events' as const, 'clips' as const], true, false, true],
          [['events' as const, 'clips' as const], true, true, true],

          [['events' as const], false, false, true],
          [['events' as const], false, true, true],
          [['events' as const], true, false, true],
          [['events' as const], true, true, true],

          [['snapshots' as const, 'clips' as const], false, false, false],
          [['snapshots' as const, 'clips' as const], false, true, true],
          [['snapshots' as const, 'clips' as const], true, false, true],
          [['snapshots' as const, 'clips' as const], true, true, true],

          [['snapshots' as const], false, false, false],
          [['snapshots' as const], false, true, false],
          [['snapshots' as const], true, false, true],
          [['snapshots' as const], true, true, true],

          [['clips' as const], false, false, false],
          [['clips' as const], false, true, true],
          [['clips' as const], true, false, false],
          [['clips' as const], true, true, true],
        ])(
          'with events %s when snapshot %s and clip %s',
          async (
            events: CameraTriggerEventType[],
            hasSnapshot: boolean,
            hasClip: boolean,
            call: boolean,
          ) => {
            const eventCallback = vi.fn();
            const camera = new FrigateCamera(
              createCameraConfig({
                id: 'CAMERA_1',
                frigate: {
                  camera_name: 'camera.front_door',
                },
                triggers: {
                  events: events,
                },
              }),
              mock<CameraManagerEngine>(),
              {
                eventCallback: eventCallback,
              },
            );

            const hass = createHASS();
            await camera.initialize(hass, mock<EntityRegistryManager>());

            callHASubscribeMessageHandler(
              hass,
              createFrigateEventChangeTrigger(
                'new',
                {
                  camera: 'camera.front_door',
                  snapshot: null,
                  has_clip: false,
                  has_snapshot: false,
                  label: 'person',
                  current_zones: [],
                },
                {
                  camera: 'camera.front_door',
                  snapshot: null,
                  has_clip: hasClip,
                  has_snapshot: hasSnapshot,
                  label: 'person',
                  current_zones: [],
                },
              ),
            );

            if (call) {
              expect(eventCallback).toBeCalledWith({
                type: 'new',
                cameraID: 'CAMERA_1',
                clip: hasClip && events.includes('clips'),
                snapshot: hasSnapshot && events.includes('snapshots'),
                fidelity: 'high',
              });
            } else {
              expect(eventCallback).not.toBeCalled();
            }
          },
        );
      });

      describe('should handle zones correctly', () => {
        it.each([
          ['has no zone', [], false],
          ['has mismatched zone', ['fence'], false],
          ['has matching zone', ['front_steps'], true],
        ])('%s', async (_name: string, zones: string[], call: boolean) => {
          const eventCallback = vi.fn();
          const camera = new FrigateCamera(
            createCameraConfig({
              id: 'CAMERA_1',
              frigate: {
                camera_name: 'camera.front_door',
                zones: ['front_steps'],
              },
            }),
            mock<CameraManagerEngine>(),
            {
              eventCallback: eventCallback,
            },
          );

          const hass = createHASS();
          await camera.initialize(hass, mock<EntityRegistryManager>());

          callHASubscribeMessageHandler(
            hass,
            createFrigateEventChangeTrigger(
              'new',
              {
                camera: 'camera.front_door',
                snapshot: null,
                has_clip: false,
                has_snapshot: false,
                label: 'person',
                current_zones: [],
              },
              {
                camera: 'camera.front_door',
                snapshot: null,
                has_clip: false,
                has_snapshot: true,
                label: 'person',
                current_zones: zones,
              },
            ),
          );

          expect(eventCallback).toHaveBeenCalledTimes(call ? 1 : 0);
        });
      });

      describe('should handle labels correctly', () => {
        it.each([
          ['has mismatched label', 'car', false],
          ['has matching label', 'person', true],
        ])('%s', async (_name: string, label: string, call: boolean) => {
          const eventCallback = vi.fn();
          const camera = new FrigateCamera(
            createCameraConfig({
              id: 'CAMERA_1',
              frigate: {
                camera_name: 'camera.front_door',
                labels: ['person'],
              },
            }),
            mock<CameraManagerEngine>(),
            {
              eventCallback: eventCallback,
            },
          );

          const hass = createHASS();
          await camera.initialize(hass, mock<EntityRegistryManager>());

          callHASubscribeMessageHandler(
            hass,
            createFrigateEventChangeTrigger(
              'new',
              {
                camera: 'camera.front_door',
                snapshot: null,
                has_clip: false,
                has_snapshot: false,
                // Even new events appear to have the event label in the
                // 'before' dictionary.
                label: label,
                current_zones: [],
              },
              {
                camera: 'camera.front_door',
                snapshot: null,
                has_clip: false,
                has_snapshot: true,
                label: label,
                current_zones: [],
              },
            ),
          );

          expect(eventCallback).toHaveBeenCalledTimes(call ? 1 : 0);
        });
      });
    });
  });

  describe('should handle triggers', () => {
    const cameraEntity: Partial<Entity> = {
      config_entry_id: 'config_entry_id',
    };

    const occupancySensorEntityAll: Partial<Entity> = {
      config_entry_id: 'config_entry_id',
      disabled_by: null,
      entity_id: 'binary_sensor.foo',
      unique_id: '8c4e19d258359e82bc0cf9d47b021c46:occupancy_sensor:front_door_all',
    };

    const motionSensorEntity: Partial<Entity> = {
      config_entry_id: 'config_entry_id',
      disabled_by: null,
      entity_id: 'binary_sensor.foo',
      unique_id: '8c4e19d258359e82bc0cf9d47b021c46:motion_sensor:front_door',
    };

    describe('should detect motion sensor', () => {
      it('without a camera name', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity(motionSensorEntity),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            triggers: {
              motion: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual([]);
      });

      it('with camera entity and name', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity(motionSensorEntity),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            camera_entity: 'camera.front_door',
            frigate: {
              camera_name: 'front_door',
            },
            triggers: {
              motion: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
      });

      it('with matching entity', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity(motionSensorEntity),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
            triggers: {
              motion: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
      });

      it('without matching entity', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([]);
        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
            triggers: {
              motion: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual([]);
      });
    });

    describe('should detect occupancy sensor', () => {
      it('without a camera name', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity(occupancySensorEntityAll),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            triggers: {
              occupancy: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual([]);
      });

      it('without a camera name but with occupancy trigger', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity(occupancySensorEntityAll),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            triggers: {
              occupancy: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual([]);
      });

      it('with matching entity', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity(occupancySensorEntityAll),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
            triggers: {
              occupancy: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
      });

      it('without matching entity', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([]);
        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
            },
            triggers: {
              occupancy: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual([]);
      });

      it('with zones', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity({
            ...occupancySensorEntityAll,
            unique_id: '8c4e19d258359e82bc0cf9d47b021c46:occupancy_sensor:zone_all',
          }),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
              zones: ['zone'],
            },
            triggers: {
              occupancy: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
      });

      it('with labels', async () => {
        const entityRegistryManager = mock<EntityRegistryManager>();
        entityRegistryManager.getEntity.mockResolvedValue(
          createRegistryEntity(cameraEntity),
        );
        entityRegistryManager.getMatchingEntities.mockResolvedValue([
          createRegistryEntity({
            ...occupancySensorEntityAll,
            unique_id:
              '8c4e19d258359e82bc0cf9d47b021c46:occupancy_sensor:front_door_car',
          }),
        ]);
        const camera = new FrigateCamera(
          createCameraConfig({
            frigate: {
              camera_name: 'front_door',
              labels: ['car'],
            },
            triggers: {
              occupancy: true,
            },
          }),
          mock<CameraManagerEngine>(),
        );
        const hass = createHASS();
        await camera.initialize(hass, entityRegistryManager);

        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
      });
    });

    it('should filter entities with correct function', async () => {
      const entityRegistryManager = mock<EntityRegistryManager>();
      entityRegistryManager.getEntity.mockResolvedValue(
        createRegistryEntity(cameraEntity),
      );
      entityRegistryManager.getMatchingEntities.mockResolvedValue([
        createRegistryEntity({
          ...occupancySensorEntityAll,
        }),
      ]);
      const camera = new FrigateCamera(
        createCameraConfig({
          camera_entity: 'camera.foo',
          triggers: {
            occupancy: true,
          },
        }),
        mock<CameraManagerEngine>(),
      );
      const hass = createHASS();
      await camera.initialize(hass, entityRegistryManager);

      const filterFunc = entityRegistryManager.getMatchingEntities.mock.calls[0][1];

      expect(
        filterFunc(
          createRegistryEntity({
            config_entry_id: cameraEntity.config_entry_id,
            disabled_by: '',
            entity_id: 'binary_sensor.foo',
          }),
        ),
      ).toBeTruthy();

      expect(
        filterFunc(
          createRegistryEntity({
            config_entry_id: cameraEntity.config_entry_id,
            disabled_by: 'user',
            entity_id: 'binary_sensor.foo',
          }),
        ),
      ).toBeFalsy();

      expect(
        filterFunc(
          createRegistryEntity({
            config_entry_id: cameraEntity.config_entry_id,
            disabled_by: '',
            entity_id: 'camera.is_not_a_binary_sensor',
          }),
        ),
      ).toBeFalsy();

      expect(
        filterFunc(
          createRegistryEntity({
            config_entry_id: 'not_a_matching_config_entry_id',
            disabled_by: '',
            entity_id: 'binary_sensor.foo',
          }),
        ),
      ).toBeFalsy();
    });
  });
});