@fastybird/smart-panel-backend 0.1.0-alpha.5

package/dist/modules/spaces/services/lighting-intent.service.js

@@ -0,0 +1,969 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightingIntentService = void 0;
+exports.selectLightsForMode = selectLightsForMode;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const extension_logger_service_1 = require("../../../common/logger/extension-logger.service");
+const devices_constants_1 = require("../../devices/devices.constants");
+const platform_registry_service_1 = require("../../devices/services/platform.registry.service");
+const intents_constants_1 = require("../../intents/intents.constants");
+const intent_timeseries_service_1 = require("../../intents/services/intent-timeseries.service");
+const intents_service_1 = require("../../intents/services/intents.service");
+const spaces_response_model_1 = require("../models/spaces-response.model");
+const spaces_constants_1 = require("../spaces.constants");
+const spec_1 = require("../spec");
+const space_context_snapshot_service_1 = require("./space-context-snapshot.service");
+const space_intent_base_service_1 = require("./space-intent-base.service");
+const space_lighting_role_service_1 = require("./space-lighting-role.service");
+const space_lighting_state_service_1 = require("./space-lighting-state.service");
+const space_undo_history_service_1 = require("./space-undo-history.service");
+const spaces_service_1 = require("./spaces.service");
+function selectLightsForMode(lights, mode, config) {
+    const selections = [];
+    const hasAnyRoles = lights.some((light) => light.role !== null);
+    if (!hasAnyRoles) {
+        const mvpBrightness = config.mvpBrightness;
+        for (const light of lights) {
+            selections.push({
+                light,
+                rule: { on: true, brightness: mvpBrightness },
+                isFallback: true,
+            });
+        }
+        return selections;
+    }
+    let useFallback = false;
+    if (mode === spaces_constants_1.LightingMode.NIGHT && config.fallbackRoles) {
+        const hasNightLights = lights.some((light) => light.role === spaces_constants_1.LightingRole.NIGHT);
+        if (!hasNightLights) {
+            useFallback = true;
+        }
+    }
+    for (const light of lights) {
+        let rule;
+        let isFallback = false;
+        if (light.role === null) {
+            const otherRule = config.roles[spaces_constants_1.LightingRole.OTHER];
+            rule = otherRule ? { on: otherRule.on, brightness: otherRule.brightness } : { on: false, brightness: null };
+        }
+        else if (useFallback && config.fallbackRoles?.includes(light.role)) {
+            rule = { on: true, brightness: config.fallbackBrightness ?? 20 };
+            isFallback = true;
+        }
+        else {
+            const roleRule = config.roles[light.role];
+            rule = roleRule ? { on: roleRule.on, brightness: roleRule.brightness } : { on: false, brightness: null };
+        }
+        selections.push({ light, rule, isFallback });
+    }
+    return selections;
+}
+let LightingIntentService = class LightingIntentService extends space_intent_base_service_1.SpaceIntentBaseService {
+    constructor(spacesService, platformRegistryService, lightingRoleService, eventEmitter, contextSnapshotService, undoHistoryService, intentTimeseriesService, lightingStateService, intentSpecLoaderService, intentsService) {
+        super();
+        this.spacesService = spacesService;
+        this.platformRegistryService = platformRegistryService;
+        this.lightingRoleService = lightingRoleService;
+        this.eventEmitter = eventEmitter;
+        this.contextSnapshotService = contextSnapshotService;
+        this.undoHistoryService = undoHistoryService;
+        this.intentTimeseriesService = intentTimeseriesService;
+        this.lightingStateService = lightingStateService;
+        this.intentSpecLoaderService = intentSpecLoaderService;
+        this.intentsService = intentsService;
+        this.logger = (0, extension_logger_service_1.createExtensionLogger)(spaces_constants_1.SPACES_MODULE_NAME, 'LightingIntentService');
+    }
+    async executeLightingIntent(spaceId, intent) {
+        const space = await this.spacesService.findOne(spaceId);
+        if (!space) {
+            this.logger.warn(`Space not found id=${spaceId}`);
+            return null;
+        }
+        const allLights = await this.getLightsInSpace(spaceId);
+        if (allLights.length === 0) {
+            this.logger.debug(`No lights found in space id=${spaceId}`);
+            return { success: true, affectedDevices: 0, failedDevices: 0, skippedOfflineDevices: 0 };
+        }
+        const { online: lights, offlineIds } = this.filterOfflineDevices(allLights);
+        if (offlineIds.length > 0) {
+            this.logger.debug(`Skipping ${offlineIds.length} offline device(s) in space id=${spaceId}`);
+        }
+        const targetedOfflineIds = this.filterOfflineIdsByRole(allLights, offlineIds, intent);
+        const hasOnlineTargetedDevices = this.isRoleSpecificIntent(intent.type) && intent.role
+            ? lights.some((l) => {
+                if (intent.role === spaces_constants_1.LightingRole.OTHER) {
+                    return l.role === spaces_constants_1.LightingRole.OTHER || l.role === null;
+                }
+                return l.role === intent.role;
+            })
+            : lights.length > 0;
+        if (!hasOnlineTargetedDevices && targetedOfflineIds.length > 0) {
+            this.logger.warn(`All ${targetedOfflineIds.length} targeted device(s) are offline in space id=${spaceId}`);
+            return {
+                success: false,
+                affectedDevices: 0,
+                failedDevices: 0,
+                skippedOfflineDevices: targetedOfflineIds.length,
+                offlineDeviceIds: targetedOfflineIds,
+            };
+        }
+        this.logger.debug(`Found ${lights.length} online lights in space id=${spaceId}`);
+        const targets = this.buildLightingTargets(allLights, intent);
+        const intentRecord = this.intentsService.createIntent({
+            type: this.mapLightingIntentType(intent.type),
+            context: {
+                origin: 'panel.spaces',
+                spaceId,
+                roleKey: intent.role ?? undefined,
+            },
+            targets,
+            value: this.buildLightingIntentValue(intent),
+            ttlMs: intents_constants_1.DEFAULT_TTL_SPACE_COMMAND,
+        });
+        await this.captureUndoSnapshot(spaceId, intent);
+        let result;
+        const targetResults = [];
+        for (const deviceId of targetedOfflineIds) {
+            const offlineLights = allLights.filter((l) => l.device.id === deviceId);
+            for (const offlineLight of offlineLights) {
+                targetResults.push({
+                    deviceId: offlineLight.device.id,
+                    channelId: offlineLight.lightChannel.id,
+                    status: intents_constants_1.IntentTargetStatus.SKIPPED,
+                    error: 'Device offline',
+                });
+            }
+        }
+        if (intent.type === spaces_constants_1.LightingIntentType.SET_MODE && intent.mode) {
+            result = await this.executeModeIntentWithResults(spaceId, lights, intent.mode, allLights.length, targetResults);
+        }
+        else if (this.isRoleSpecificIntent(intent.type)) {
+            result = await this.executeRoleIntentWithResults(spaceId, lights, intent, targetResults);
+        }
+        else {
+            let affectedDevices = 0;
+            let failedDevices = 0;
+            for (const light of lights) {
+                const success = await this.executeIntentForLight(light, intent);
+                targetResults.push({
+                    deviceId: light.device.id,
+                    channelId: light.lightChannel.id,
+                    status: success ? intents_constants_1.IntentTargetStatus.SUCCESS : intents_constants_1.IntentTargetStatus.FAILED,
+                });
+                if (success) {
+                    affectedDevices++;
+                }
+                else {
+                    failedDevices++;
+                }
+            }
+            const overallSuccess = failedDevices === 0 || affectedDevices > 0;
+            this.logger.debug(`Lighting intent completed spaceId=${spaceId} affected=${affectedDevices} failed=${failedDevices} skipped=${targetedOfflineIds.length}`);
+            if (intent.type === spaces_constants_1.LightingIntentType.OFF && overallSuccess) {
+                void this.intentTimeseriesService.storeLightingModeChange(spaceId, spaces_constants_1.LightingMode.OFF, allLights.length, affectedDevices, failedDevices);
+            }
+            result = { success: overallSuccess, affectedDevices, failedDevices };
+        }
+        if (result.success) {
+            if (intent.type === spaces_constants_1.LightingIntentType.OFF) {
+                void this.intentTimeseriesService.storeModeValidity(spaceId, 'lighting', true);
+            }
+            else if (intent.type !== spaces_constants_1.LightingIntentType.SET_MODE) {
+                void this.intentTimeseriesService.storeModeValidity(spaceId, 'lighting', false);
+            }
+        }
+        result.skippedOfflineDevices = targetedOfflineIds.length;
+        if (targetedOfflineIds.length > 0) {
+            result.offlineDeviceIds = targetedOfflineIds;
+        }
+        result.failedTargets = targetResults.filter((t) => t.status === intents_constants_1.IntentTargetStatus.FAILED).map((t) => t.deviceId);
+        this.intentsService.completeIntent(intentRecord.id, targetResults);
+        if (result.success) {
+            void this.emitLightingStateChange(spaceId);
+        }
+        return result;
+    }
+    buildLightingTargets(lights, intent) {
+        if (this.isRoleSpecificIntent(intent.type) && intent.role) {
+            const roleLights = lights.filter((light) => {
+                if (intent.role === spaces_constants_1.LightingRole.OTHER) {
+                    return light.role === spaces_constants_1.LightingRole.OTHER || light.role === null;
+                }
+                return light.role === intent.role;
+            });
+            return roleLights.map((light) => ({
+                deviceId: light.device.id,
+                channelId: light.lightChannel.id,
+            }));
+        }
+        return lights.map((light) => ({
+            deviceId: light.device.id,
+            channelId: light.lightChannel.id,
+        }));
+    }
+    filterOfflineIdsByRole(allLights, offlineIds, intent) {
+        if (!this.isRoleSpecificIntent(intent.type) || !intent.role) {
+            return offlineIds;
+        }
+        return offlineIds.filter((deviceId) => {
+            return allLights.some((l) => {
+                if (l.device.id !== deviceId) {
+                    return false;
+                }
+                if (intent.role === spaces_constants_1.LightingRole.OTHER) {
+                    return l.role === spaces_constants_1.LightingRole.OTHER || l.role === null;
+                }
+                return l.role === intent.role;
+            });
+        });
+    }
+    mapLightingIntentType(type) {
+        switch (type) {
+            case spaces_constants_1.LightingIntentType.ON:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ON;
+            case spaces_constants_1.LightingIntentType.OFF:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_OFF;
+            case spaces_constants_1.LightingIntentType.SET_MODE:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_SET_MODE;
+            case spaces_constants_1.LightingIntentType.BRIGHTNESS_DELTA:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_BRIGHTNESS_DELTA;
+            case spaces_constants_1.LightingIntentType.ROLE_ON:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_ON;
+            case spaces_constants_1.LightingIntentType.ROLE_OFF:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_OFF;
+            case spaces_constants_1.LightingIntentType.ROLE_BRIGHTNESS:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_BRIGHTNESS;
+            case spaces_constants_1.LightingIntentType.ROLE_COLOR:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_COLOR;
+            case spaces_constants_1.LightingIntentType.ROLE_COLOR_TEMP:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_COLOR_TEMP;
+            case spaces_constants_1.LightingIntentType.ROLE_WHITE:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_WHITE;
+            case spaces_constants_1.LightingIntentType.ROLE_SET:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ROLE_SET;
+            default:
+                return intents_constants_1.IntentType.SPACE_LIGHTING_ON;
+        }
+    }
+    buildLightingIntentValue(intent) {
+        const value = {};
+        if (intent.mode !== undefined)
+            value.mode = intent.mode;
+        if (intent.delta !== undefined)
+            value.delta = intent.delta;
+        if (intent.increase !== undefined)
+            value.increase = intent.increase;
+        if (intent.role !== undefined)
+            value.role = intent.role;
+        if (intent.on !== undefined)
+            value.on = intent.on;
+        if (intent.brightness !== undefined)
+            value.brightness = intent.brightness;
+        if (intent.color !== undefined)
+            value.color = intent.color;
+        if (intent.colorTemperature !== undefined)
+            value.colorTemperature = intent.colorTemperature;
+        if (intent.white !== undefined)
+            value.white = intent.white;
+        return Object.keys(value).length > 0 ? value : null;
+    }
+    async emitLightingStateChange(spaceId) {
+        try {
+            const state = await this.lightingStateService.getLightingState(spaceId, {
+                synchronizeModeValidity: false,
+            });
+            if (state) {
+                const stateModel = spaces_response_model_1.LightingStateDataModel.fromState(state);
+                this.eventEmitter.emit(spaces_constants_1.EventType.LIGHTING_STATE_CHANGED, {
+                    space_id: spaceId,
+                    state: stateModel,
+                });
+                this.logger.debug(`Emitted lighting state change event spaceId=${spaceId}`);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Failed to emit lighting state change event spaceId=${spaceId}: ${error}`);
+        }
+    }
+    async executeModeIntent(spaceId, lights, mode) {
+        const modeConfig = this.intentSpecLoaderService.getLightingModeOrchestration(mode);
+        if (!modeConfig) {
+            this.logger.warn(`No orchestration config found for mode=${mode}, using defaults`);
+            return { success: false, affectedDevices: 0, failedDevices: 0 };
+        }
+        const selections = selectLightsForMode(lights, mode, modeConfig);
+        const onLights = selections.filter((s) => s.rule.on);
+        const offLights = selections.filter((s) => !s.rule.on);
+        const hasRoles = lights.some((l) => l.role !== null);
+        const usingFallback = selections.some((s) => s.isFallback);
+        this.logger.log(`Mode intent spaceId=${spaceId} mode=${mode} ` +
+            `totalLights=${lights.length} onCount=${onLights.length} offCount=${offLights.length} ` +
+            `hasRoles=${hasRoles} usingFallback=${usingFallback}`);
+        let affectedDevices = 0;
+        let failedDevices = 0;
+        for (const selection of selections) {
+            const success = await this.executeRuleForLight(selection.light, selection.rule);
+            if (success) {
+                affectedDevices++;
+            }
+            else {
+                failedDevices++;
+            }
+        }
+        const overallSuccess = failedDevices === 0 || affectedDevices > 0;
+        this.logger.debug(`Mode intent completed spaceId=${spaceId} mode=${mode} affected=${affectedDevices} failed=${failedDevices}`);
+        if (overallSuccess) {
+            void this.intentTimeseriesService.storeLightingModeChange(spaceId, mode, selections.length, affectedDevices, failedDevices);
+            void this.intentTimeseriesService.storeModeValidity(spaceId, 'lighting', true);
+        }
+        return { success: overallSuccess, affectedDevices, failedDevices };
+    }
+    async executeModeIntentWithResults(spaceId, lights, mode, totalLightsCount, targetResults) {
+        const modeConfig = this.intentSpecLoaderService.getLightingModeOrchestration(mode);
+        if (!modeConfig) {
+            this.logger.warn(`No orchestration config found for mode=${mode}, using defaults`);
+            return { success: false, affectedDevices: 0, failedDevices: 0 };
+        }
+        const selections = selectLightsForMode(lights, mode, modeConfig);
+        const onLights = selections.filter((s) => s.rule.on);
+        const offLights = selections.filter((s) => !s.rule.on);
+        const hasRoles = lights.some((l) => l.role !== null);
+        const usingFallback = selections.some((s) => s.isFallback);
+        this.logger.log(`Mode intent spaceId=${spaceId} mode=${mode} ` +
+            `totalLights=${lights.length} onCount=${onLights.length} offCount=${offLights.length} ` +
+            `hasRoles=${hasRoles} usingFallback=${usingFallback}`);
+        let affectedDevices = 0;
+        let failedDevices = 0;
+        for (const selection of selections) {
+            const success = await this.executeRuleForLight(selection.light, selection.rule);
+            targetResults.push({
+                deviceId: selection.light.device.id,
+                channelId: selection.light.lightChannel.id,
+                status: success ? intents_constants_1.IntentTargetStatus.SUCCESS : intents_constants_1.IntentTargetStatus.FAILED,
+            });
+            if (success) {
+                affectedDevices++;
+            }
+            else {
+                failedDevices++;
+            }
+        }
+        const overallSuccess = failedDevices === 0 || affectedDevices > 0;
+        this.logger.debug(`Mode intent completed spaceId=${spaceId} mode=${mode} affected=${affectedDevices} failed=${failedDevices}`);
+        if (overallSuccess) {
+            void this.intentTimeseriesService.storeLightingModeChange(spaceId, mode, totalLightsCount, affectedDevices, failedDevices);
+            void this.intentTimeseriesService.storeModeValidity(spaceId, 'lighting', true);
+        }
+        return { success: overallSuccess, affectedDevices, failedDevices };
+    }
+    async executeRuleForLight(light, rule) {
+        const platform = this.platformRegistryService.get(light.device);
+        if (!platform) {
+            this.logger.warn(`No platform registered for device id=${light.device.id} type=${light.device.type}`);
+            return false;
+        }
+        const commands = [];
+        commands.push({
+            device: light.device,
+            channel: light.lightChannel,
+            property: light.onProperty,
+            value: rule.on,
+        });
+        if (rule.on && rule.brightness !== null && light.brightnessProperty) {
+            commands.push({
+                device: light.device,
+                channel: light.lightChannel,
+                property: light.brightnessProperty,
+                value: rule.brightness,
+            });
+        }
+        try {
+            const success = await platform.processBatch(commands);
+            if (!success) {
+                this.logger.error(`Rule execution failed for device id=${light.device.id}`);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error executing rule for device id=${light.device.id}: ${error}`);
+            return false;
+        }
+    }
+    async getLightsInSpace(spaceId) {
+        const devices = await this.spacesService.findDevicesBySpace(spaceId);
+        const lights = [];
+        const roleMap = await this.lightingRoleService.getRoleMap(spaceId);
+        for (const device of devices) {
+            if (device.category !== devices_constants_1.DeviceCategory.LIGHTING) {
+                continue;
+            }
+            const lightChannels = device.channels?.filter((ch) => ch.category === devices_constants_1.ChannelCategory.LIGHT) ?? [];
+            for (const lightChannel of lightChannels) {
+                const onProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.ON);
+                if (!onProperty) {
+                    continue;
+                }
+                const brightnessProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.BRIGHTNESS) ?? null;
+                const colorRedProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.COLOR_RED) ?? null;
+                const colorGreenProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.COLOR_GREEN) ?? null;
+                const colorBlueProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.COLOR_BLUE) ?? null;
+                const hueProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.HUE) ?? null;
+                const saturationProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.SATURATION) ?? null;
+                const colorTempProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.COLOR_TEMPERATURE) ?? null;
+                const whiteProperty = lightChannel.properties?.find((p) => p.category === devices_constants_1.PropertyCategory.COLOR_WHITE) ?? null;
+                const roleKey = `${device.id}:${lightChannel.id}`;
+                const roleEntity = roleMap.get(roleKey);
+                const role = roleEntity?.role ?? null;
+                if (role === spaces_constants_1.LightingRole.HIDDEN) {
+                    this.logger.debug(`Skipping HIDDEN light deviceId=${device.id} channelId=${lightChannel.id}`);
+                    continue;
+                }
+                lights.push({
+                    device,
+                    lightChannel,
+                    onProperty,
+                    brightnessProperty,
+                    colorRedProperty,
+                    colorGreenProperty,
+                    colorBlueProperty,
+                    hueProperty,
+                    saturationProperty,
+                    colorTempProperty,
+                    whiteProperty,
+                    role,
+                });
+            }
+        }
+        return lights;
+    }
+    async executeIntentForLight(light, intent) {
+        const platform = this.platformRegistryService.get(light.device);
+        if (!platform) {
+            this.logger.warn(`No platform registered for device id=${light.device.id} type=${light.device.type}`);
+            return false;
+        }
+        const commands = [];
+        switch (intent.type) {
+            case spaces_constants_1.LightingIntentType.OFF:
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.onProperty,
+                    value: false,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.ON:
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.onProperty,
+                    value: true,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.BRIGHTNESS_DELTA:
+                if (intent.delta === undefined || intent.increase === undefined) {
+                    this.logger.warn('BRIGHTNESS_DELTA intent requires delta and increase parameters');
+                    return false;
+                }
+                commands.push(...this.buildBrightnessDeltaCommands(light, intent.delta, intent.increase));
+                break;
+            case spaces_constants_1.LightingIntentType.SET_MODE:
+                this.logger.warn('SET_MODE should be handled via executeModeIntent');
+                return false;
+            default:
+                this.logger.warn(`Unknown intent type: ${String(intent.type)}`);
+                return false;
+        }
+        if (commands.length === 0) {
+            this.logger.debug(`No commands to execute for device id=${light.device.id}`);
+            return true;
+        }
+        try {
+            const success = await platform.processBatch(commands);
+            if (!success) {
+                this.logger.error(`Command execution failed for device id=${light.device.id}`);
+                return false;
+            }
+            this.logger.debug(`Successfully executed commands for device id=${light.device.id}`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error executing commands for device id=${light.device.id}: ${error}`);
+            return false;
+        }
+    }
+    buildBrightnessDeltaCommands(light, delta, increase) {
+        const commands = [];
+        if (!light.brightnessProperty) {
+            this.logger.debug(`Device does not support brightness adjustment deviceId=${light.device.id}`);
+            return commands;
+        }
+        const isOn = this.getPropertyBooleanValue(light.onProperty);
+        if (!isOn) {
+            this.logger.debug(`Skipping brightness delta for OFF device deviceId=${light.device.id}`);
+            return commands;
+        }
+        const currentBrightness = this.getPropertyNumericValue(light.brightnessProperty) ?? 50;
+        const deltaValue = this.intentSpecLoaderService.getBrightnessDeltaStep(delta) ?? 25;
+        let newBrightness = increase ? currentBrightness + deltaValue : currentBrightness - deltaValue;
+        newBrightness = this.clampValue(newBrightness, 0, 100);
+        commands.push({
+            device: light.device,
+            channel: light.lightChannel,
+            property: light.brightnessProperty,
+            value: newBrightness,
+        });
+        return commands;
+    }
+    async captureUndoSnapshot(spaceId, intent) {
+        try {
+            const snapshot = await this.contextSnapshotService.captureSnapshot(spaceId);
+            if (!snapshot) {
+                this.logger.debug(`Could not capture snapshot for undo spaceId=${spaceId}`);
+                return;
+            }
+            const actionDescription = this.buildIntentDescription(intent);
+            this.undoHistoryService.pushSnapshot(snapshot, actionDescription, 'lighting');
+            this.logger.debug(`Undo snapshot captured spaceId=${spaceId} action="${actionDescription}"`);
+        }
+        catch (error) {
+            this.logger.error(`Error capturing undo snapshot spaceId=${spaceId}: ${error}`);
+        }
+    }
+    buildIntentDescription(intent) {
+        switch (intent.type) {
+            case spaces_constants_1.LightingIntentType.OFF:
+                return 'Turn lights off';
+            case spaces_constants_1.LightingIntentType.ON:
+                return 'Turn lights on';
+            case spaces_constants_1.LightingIntentType.SET_MODE:
+                return `Set lighting mode to ${intent.mode ?? 'unknown'}`;
+            case spaces_constants_1.LightingIntentType.BRIGHTNESS_DELTA:
+                return intent.increase ? 'Increase brightness' : 'Decrease brightness';
+            case spaces_constants_1.LightingIntentType.ROLE_ON:
+                return `Turn ${intent.role ?? 'role'} lights on`;
+            case spaces_constants_1.LightingIntentType.ROLE_OFF:
+                return `Turn ${intent.role ?? 'role'} lights off`;
+            case spaces_constants_1.LightingIntentType.ROLE_BRIGHTNESS:
+                return `Set ${intent.role ?? 'role'} brightness to ${intent.brightness ?? 0}%`;
+            case spaces_constants_1.LightingIntentType.ROLE_COLOR:
+                return `Set ${intent.role ?? 'role'} color to ${intent.color ?? 'unknown'}`;
+            case spaces_constants_1.LightingIntentType.ROLE_COLOR_TEMP:
+                return `Set ${intent.role ?? 'role'} color temperature to ${intent.colorTemperature ?? 0}K`;
+            case spaces_constants_1.LightingIntentType.ROLE_WHITE:
+                return `Set ${intent.role ?? 'role'} white to ${intent.white ?? 0}%`;
+            case spaces_constants_1.LightingIntentType.ROLE_SET:
+                return this.buildRoleSetDescription(intent);
+            default:
+                return 'Lighting intent';
+        }
+    }
+    buildRoleSetDescription(intent) {
+        const parts = [];
+        const role = intent.role ?? 'role';
+        if (intent.on !== undefined) {
+            parts.push(intent.on ? 'on' : 'off');
+        }
+        if (intent.brightness !== undefined) {
+            parts.push(`brightness ${intent.brightness}%`);
+        }
+        if (intent.color) {
+            parts.push(`color ${intent.color}`);
+        }
+        if (intent.colorTemperature !== undefined) {
+            parts.push(`temp ${intent.colorTemperature}K`);
+        }
+        if (intent.white !== undefined) {
+            parts.push(`white ${intent.white}%`);
+        }
+        if (parts.length === 0) {
+            return `Set ${role} properties`;
+        }
+        return `Set ${role}: ${parts.join(', ')}`;
+    }
+    isRoleSpecificIntent(type) {
+        return [
+            spaces_constants_1.LightingIntentType.ROLE_ON,
+            spaces_constants_1.LightingIntentType.ROLE_OFF,
+            spaces_constants_1.LightingIntentType.ROLE_BRIGHTNESS,
+            spaces_constants_1.LightingIntentType.ROLE_COLOR,
+            spaces_constants_1.LightingIntentType.ROLE_COLOR_TEMP,
+            spaces_constants_1.LightingIntentType.ROLE_WHITE,
+            spaces_constants_1.LightingIntentType.ROLE_SET,
+        ].includes(type);
+    }
+    async executeRoleIntent(spaceId, allLights, intent) {
+        if (!intent.role) {
+            this.logger.warn('Role-specific intent missing role parameter');
+            return { success: false, affectedDevices: 0, failedDevices: 0 };
+        }
+        const roleLights = allLights.filter((light) => {
+            if (intent.role === spaces_constants_1.LightingRole.OTHER) {
+                return light.role === spaces_constants_1.LightingRole.OTHER || light.role === null;
+            }
+            return light.role === intent.role;
+        });
+        if (roleLights.length === 0) {
+            this.logger.debug(`No lights found with role=${intent.role} in space id=${spaceId}`);
+            return { success: true, affectedDevices: 0, failedDevices: 0 };
+        }
+        this.logger.debug(`Executing role intent type=${intent.type} role=${intent.role} lightsCount=${roleLights.length}`);
+        let affectedDevices = 0;
+        let failedDevices = 0;
+        for (const light of roleLights) {
+            const success = await this.executeRoleIntentForLight(light, intent);
+            if (success) {
+                affectedDevices++;
+            }
+            else {
+                failedDevices++;
+            }
+        }
+        const overallSuccess = failedDevices === 0 || affectedDevices > 0;
+        this.logger.debug(`Role intent completed spaceId=${spaceId} role=${intent.role} affected=${affectedDevices} failed=${failedDevices}`);
+        return { success: overallSuccess, affectedDevices, failedDevices };
+    }
+    async executeRoleIntentWithResults(spaceId, allLights, intent, targetResults) {
+        if (!intent.role) {
+            this.logger.warn('Role-specific intent missing role parameter');
+            return { success: false, affectedDevices: 0, failedDevices: 0 };
+        }
+        const roleLights = allLights.filter((light) => {
+            if (intent.role === spaces_constants_1.LightingRole.OTHER) {
+                return light.role === spaces_constants_1.LightingRole.OTHER || light.role === null;
+            }
+            return light.role === intent.role;
+        });
+        if (roleLights.length === 0) {
+            this.logger.debug(`No lights found with role=${intent.role} in space id=${spaceId}`);
+            return { success: true, affectedDevices: 0, failedDevices: 0 };
+        }
+        this.logger.debug(`Executing role intent type=${intent.type} role=${intent.role} lightsCount=${roleLights.length}`);
+        let affectedDevices = 0;
+        let failedDevices = 0;
+        for (const light of roleLights) {
+            const success = await this.executeRoleIntentForLight(light, intent);
+            targetResults.push({
+                deviceId: light.device.id,
+                channelId: light.lightChannel.id,
+                status: success ? intents_constants_1.IntentTargetStatus.SUCCESS : intents_constants_1.IntentTargetStatus.FAILED,
+            });
+            if (success) {
+                affectedDevices++;
+            }
+            else {
+                failedDevices++;
+            }
+        }
+        const overallSuccess = failedDevices === 0 || affectedDevices > 0;
+        this.logger.debug(`Role intent completed spaceId=${spaceId} role=${intent.role} affected=${affectedDevices} failed=${failedDevices}`);
+        return { success: overallSuccess, affectedDevices, failedDevices };
+    }
+    async executeRoleIntentForLight(light, intent) {
+        const platform = this.platformRegistryService.get(light.device);
+        if (!platform) {
+            this.logger.warn(`No platform registered for device id=${light.device.id} type=${light.device.type}`);
+            return false;
+        }
+        const commands = [];
+        switch (intent.type) {
+            case spaces_constants_1.LightingIntentType.ROLE_ON:
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.onProperty,
+                    value: true,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.ROLE_OFF:
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.onProperty,
+                    value: false,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.ROLE_BRIGHTNESS:
+                if (intent.brightness === undefined) {
+                    this.logger.warn('ROLE_BRIGHTNESS intent missing brightness parameter');
+                    return false;
+                }
+                if (!light.brightnessProperty) {
+                    this.logger.debug(`Device does not support brightness deviceId=${light.device.id}`);
+                    return true;
+                }
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.brightnessProperty,
+                    value: intent.brightness,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.ROLE_COLOR: {
+                if (!intent.color) {
+                    this.logger.warn('ROLE_COLOR intent missing color parameter');
+                    return false;
+                }
+                const hasRgb = light.colorRedProperty && light.colorGreenProperty && light.colorBlueProperty;
+                const hasHueSat = light.hueProperty && light.saturationProperty;
+                if (!hasRgb && !hasHueSat) {
+                    this.logger.debug(`Device does not support color control deviceId=${light.device.id}`);
+                    return true;
+                }
+                if (hasRgb) {
+                    const rgb = this.hexToRgb(intent.color);
+                    if (!rgb) {
+                        this.logger.warn(`Invalid hex color: ${intent.color}`);
+                        return false;
+                    }
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.colorRedProperty,
+                        value: rgb.red,
+                    });
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.colorGreenProperty,
+                        value: rgb.green,
+                    });
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.colorBlueProperty,
+                        value: rgb.blue,
+                    });
+                }
+                else if (hasHueSat) {
+                    const hsv = this.hexToHsv(intent.color);
+                    if (!hsv) {
+                        this.logger.warn(`Invalid hex color: ${intent.color}`);
+                        return false;
+                    }
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.hueProperty,
+                        value: hsv.hue,
+                    });
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.saturationProperty,
+                        value: hsv.saturation,
+                    });
+                }
+                break;
+            }
+            case spaces_constants_1.LightingIntentType.ROLE_COLOR_TEMP:
+                if (intent.colorTemperature === undefined) {
+                    this.logger.warn('ROLE_COLOR_TEMP intent missing colorTemperature parameter');
+                    return false;
+                }
+                if (!light.colorTempProperty) {
+                    this.logger.debug(`Device does not support color temperature deviceId=${light.device.id}`);
+                    return true;
+                }
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.colorTempProperty,
+                    value: intent.colorTemperature,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.ROLE_WHITE:
+                if (intent.white === undefined) {
+                    this.logger.warn('ROLE_WHITE intent missing white parameter');
+                    return false;
+                }
+                if (!light.whiteProperty) {
+                    this.logger.debug(`Device does not support white channel deviceId=${light.device.id}`);
+                    return true;
+                }
+                commands.push({
+                    device: light.device,
+                    channel: light.lightChannel,
+                    property: light.whiteProperty,
+                    value: intent.white,
+                });
+                break;
+            case spaces_constants_1.LightingIntentType.ROLE_SET:
+                if (intent.on !== undefined) {
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.onProperty,
+                        value: intent.on,
+                    });
+                }
+                if (intent.brightness !== undefined && light.brightnessProperty) {
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.brightnessProperty,
+                        value: intent.brightness,
+                    });
+                }
+                if (intent.color) {
+                    const hasRgb = light.colorRedProperty && light.colorGreenProperty && light.colorBlueProperty;
+                    const hasHueSat = light.hueProperty && light.saturationProperty;
+                    if (hasRgb) {
+                        const rgb = this.hexToRgb(intent.color);
+                        if (rgb) {
+                            commands.push({
+                                device: light.device,
+                                channel: light.lightChannel,
+                                property: light.colorRedProperty,
+                                value: rgb.red,
+                            });
+                            commands.push({
+                                device: light.device,
+                                channel: light.lightChannel,
+                                property: light.colorGreenProperty,
+                                value: rgb.green,
+                            });
+                            commands.push({
+                                device: light.device,
+                                channel: light.lightChannel,
+                                property: light.colorBlueProperty,
+                                value: rgb.blue,
+                            });
+                        }
+                    }
+                    else if (hasHueSat) {
+                        const hsv = this.hexToHsv(intent.color);
+                        if (hsv) {
+                            commands.push({
+                                device: light.device,
+                                channel: light.lightChannel,
+                                property: light.hueProperty,
+                                value: hsv.hue,
+                            });
+                            commands.push({
+                                device: light.device,
+                                channel: light.lightChannel,
+                                property: light.saturationProperty,
+                                value: hsv.saturation,
+                            });
+                        }
+                    }
+                }
+                if (intent.colorTemperature !== undefined && light.colorTempProperty) {
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.colorTempProperty,
+                        value: intent.colorTemperature,
+                    });
+                }
+                if (intent.white !== undefined && light.whiteProperty) {
+                    commands.push({
+                        device: light.device,
+                        channel: light.lightChannel,
+                        property: light.whiteProperty,
+                        value: intent.white,
+                    });
+                }
+                break;
+            default:
+                this.logger.warn(`Unknown role intent type: ${String(intent.type)}`);
+                return false;
+        }
+        if (commands.length === 0) {
+            return true;
+        }
+        try {
+            const success = await platform.processBatch(commands);
+            if (!success) {
+                this.logger.error(`Role intent execution failed for device id=${light.device.id}`);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error executing role intent for device id=${light.device.id}: ${error}`);
+            return false;
+        }
+    }
+    filterOfflineDevices(lights) {
+        const online = [];
+        const offlineIdSet = new Set();
+        for (const light of lights) {
+            if (light.device.status.online) {
+                online.push(light);
+            }
+            else {
+                offlineIdSet.add(light.device.id);
+            }
+        }
+        return { online, offlineIds: [...offlineIdSet] };
+    }
+    hexToRgb(hex) {
+        const result = /^#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/.exec(hex);
+        if (!result) {
+            return null;
+        }
+        return {
+            red: parseInt(result[1], 16),
+            green: parseInt(result[2], 16),
+            blue: parseInt(result[3], 16),
+        };
+    }
+    hexToHsv(hex) {
+        const rgb = this.hexToRgb(hex);
+        if (!rgb) {
+            return null;
+        }
+        const r = rgb.red / 255;
+        const g = rgb.green / 255;
+        const b = rgb.blue / 255;
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        const delta = max - min;
+        let hue = 0;
+        if (delta !== 0) {
+            if (max === r) {
+                hue = ((g - b) / delta) % 6;
+            }
+            else if (max === g) {
+                hue = (b - r) / delta + 2;
+            }
+            else {
+                hue = (r - g) / delta + 4;
+            }
+            hue = Math.round(hue * 60);
+            if (hue < 0) {
+                hue += 360;
+            }
+        }
+        const saturation = max === 0 ? 0 : Math.round((delta / max) * 100);
+        return { hue, saturation };
+    }
+};
+exports.LightingIntentService = LightingIntentService;
+exports.LightingIntentService = LightingIntentService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [spaces_service_1.SpacesService,
+        platform_registry_service_1.PlatformRegistryService,
+        space_lighting_role_service_1.SpaceLightingRoleService,
+        event_emitter_1.EventEmitter2,
+        space_context_snapshot_service_1.SpaceContextSnapshotService,
+        space_undo_history_service_1.SpaceUndoHistoryService,
+        intent_timeseries_service_1.IntentTimeseriesService,
+        space_lighting_state_service_1.SpaceLightingStateService,
+        spec_1.IntentSpecLoaderService,
+        intents_service_1.IntentsService])
+], LightingIntentService);
+//# sourceMappingURL=lighting-intent.service.js.map