@smarthome.exchange/integrations 0.2.0 → 1.0.0

package/ts/integrations/yeelight/yeelight.classes.client.ts

@@ -1,323 +1,222 @@
 import * as plugins from '../../plugins.js';
-import type {
-  IYeelightBulbInfo,
-  IYeelightBulbProperties,
-  IYeelightCommand,
-  IYeelightCommandResponse,
-  IYeelightCommandResult,
-  IYeelightConfig,
-  IYeelightEvent,
-  IYeelightLightStatePatch,
-  IYeelightManualDeviceConfig,
-  IYeelightSnapshot,
-  TYeelightEffect,
-} from './yeelight.types.js';
+import type { IConfigStore } from '../../core/types.js';
+import type { IYeelightConfig, IYeelightEvent, IYeelightSnapshot, TYeelightControl } from './yeelight.types.js';
+import { assertYeelightScope, normalizeYeelightConfig, parseYeelightProperties, validateYeelightControl } from './yeelight.validation.js';
 
 type TYeelightEventHandler = (eventArg: IYeelightEvent) => void;
+const properties = ['power', 'bright', 'ct', 'rgb', 'hue', 'sat', 'color_mode', 'flowing', 'name'] as const;
 
-const defaultPort = 55443;
-const defaultEffect: TYeelightEffect = 'smooth';
-const defaultTransition = 350;
-const defaultPropertyRequest = [
-  'power',
-  'main_power',
-  'bright',
-  'ct',
-  'rgb',
-  'hue',
-  'sat',
-  'color_mode',
-  'flowing',
-  'delayoff',
-  'music_on',
-  'name',
-  'bg_power',
-  'bg_flowing',
-  'bg_ct',
-  'bg_bright',
-  'bg_hue',
-  'bg_sat',
-  'bg_rgb',
-  'bg_lmode',
-  'nl_br',
-  'active_mode',
-];
+export class YeelightControlError extends Error {
+  public constructor(public readonly effectOutcome: plugins.ecobridgeDeviceManager.TYeelightEffectOutcome) {
+    super('Yeelight control outcome could not be reconciled.');
+    this.name = 'YeelightControlError';
+  }
+}
 
+/** Admits one home-bound bulb; the published protocol owns all wire behavior. */
 export class YeelightClient {
-  private commandId = 1;
-  private cachedSnapshot?: IYeelightSnapshot;
-  private readonly events: IYeelightEvent[] = [];
-  private readonly eventHandlers = new Set<TYeelightEventHandler>();
-
-  constructor(private readonly config: IYeelightConfig) {}
-
-  public async getSnapshot(): Promise<IYeelightSnapshot> {
-    if (this.cachedSnapshot) {
-      return this.withEvents(this.cachedSnapshot);
-    }
-    if (this.config.snapshot) {
-      this.cachedSnapshot = this.withEvents({ ...this.config.snapshot, source: this.config.snapshot.source || 'snapshot' });
-      return this.cachedSnapshot;
-    }
-    const manualBulbs = this.manualBulbs();
-    if (manualBulbs.length) {
-      this.cachedSnapshot = this.withEvents({ connected: false, bulbs: manualBulbs, events: [], source: 'manual', updatedAt: new Date().toISOString() });
-      return this.cachedSnapshot;
-    }
-    if (!this.config.host) {
-      throw new Error('Yeelight snapshot requires config.snapshot, config.bulb/config.bulbs/config.devices, or a host for local TCP get_prop.');
-    }
-    const properties = await this.getProperties(defaultPropertyRequest);
-    this.cachedSnapshot = this.withEvents({
-      connected: true,
-      bulbs: [this.bulbFromConfig(properties)],
-      events: [],
-      source: 'tcp',
-      updatedAt: new Date().toISOString(),
-    });
-    return this.cachedSnapshot;
+  private readonly config: ReturnType<typeof normalizeYeelightConfig>;
+  private readonly lifetime = new AbortController();
+  private readonly eventHandlers = new Map<symbol, TYeelightEventHandler>();
+  private protocol?: plugins.ecobridgeDeviceManager.YeelightProtocol;
+  private advertisement?: plugins.ecobridgeDeviceManager.IYeelightAdvertisement;
+  private snapshot?: IYeelightSnapshot;
+  private startPromise?: Promise<void>;
+  private closePromise?: Promise<void>;
+  private operationTail: Promise<void> = Promise.resolve();
+  private pendingOperations = 0;
+  private needsReconciliation = false;
+  private unsubscribeProperties?: () => void;
+
+  public constructor(configArg: IYeelightConfig, private readonly configStore: IConfigStore | undefined) {
+    this.config = normalizeYeelightConfig(configArg);
+    assertYeelightScope(configStore, this.config.homeId);
+  }
+
+  public get homeId(): string { return this.config.homeId; }
+  public get bulbId(): string { return this.config.expectedId; }
+  public isHealthy(): boolean { return !this.lifetime.signal.aborted && this.protocol?.isConnected === true && this.snapshot !== undefined; }
+
+  public start(signalArg?: AbortSignal): Promise<void> {
+    if (signalArg !== undefined && !(signalArg instanceof AbortSignal)) return Promise.reject(new TypeError('Yeelight cancellation requires an AbortSignal.'));
+    if (signalArg?.aborted) return Promise.reject(signalArg.reason);
+    if (this.startPromise && this.snapshot && !this.protocol?.isConnected) return Promise.reject(new Error('Yeelight connection is terminally unavailable.'));
+    if (this.lifetime.signal.aborted) return Promise.reject(this.lifetime.signal.reason);
+    if (!this.startPromise) {
+      const deadline = this.deadline(signalArg);
+      this.startPromise = this.initialize(deadline.signal).catch(async (errorArg: unknown) => {
+        this.lifetime.abort(errorArg);
+        this.eventHandlers.clear();
+        this.unsubscribeProperties?.();
+        await this.protocol?.close();
+        throw errorArg;
+      }).finally(deadline.dispose);
+    }
+    return this.startPromise;
+  }
+
+  public getObservedSnapshot(): IYeelightSnapshot {
+    this.assertAdmitted();
+    return this.detachedSnapshot();
+  }
+
+  public getSnapshot(signalArg?: AbortSignal): Promise<IYeelightSnapshot> {
+    return this.run(async (signal) => { await this.read(signal); return this.detachedSnapshot(); }, signalArg);
+  }
+
+  public setControl(controlArg: TYeelightControl, signalArg?: AbortSignal): Promise<IYeelightSnapshot> {
+    const control = validateYeelightControl(controlArg);
+    return this.run(async (signal) => {
+      if (this.needsReconciliation) throw new YeelightControlError('not-sent');
+      const protocol = this.connectedProtocol();
+      const options = { signal, effect: this.config.effect, durationMs: this.config.transitionMs, timeoutMs: this.config.requestTimeoutMs };
+      let acknowledged = false;
+      try {
+        if (control.feature === 'power') await protocol.setPower(control.value, options);
+        else if (control.feature === 'brightness') await protocol.setBrightness(control.value, options);
+        else await protocol.setRgb(control.value[0] * 65536 + control.value[1] * 256 + control.value[2], options);
+        acknowledged = true;
+        await this.read(signal);
+        return this.detachedSnapshot();
+      } catch (errorArg) {
+        const outcome = acknowledged ? 'indeterminate' : errorArg instanceof plugins.ecobridgeDeviceManager.YeelightError ? errorArg.effectOutcome : 'indeterminate';
+        if (outcome === 'indeterminate') this.needsReconciliation = true;
+        throw new YeelightControlError(outcome);
+      }
+    }, signalArg);
   }
 
   public onEvent(handlerArg: TYeelightEventHandler): () => void {
-    this.eventHandlers.add(handlerArg);
-    return () => this.eventHandlers.delete(handlerArg);
-  }
-
-  public async getProperties(propertiesArg: string[] = defaultPropertyRequest): Promise<IYeelightBulbProperties> {
-    const response = await this.sendCommand({ method: 'get_prop', params: propertiesArg });
-    const result = response.result || [];
-    const properties: IYeelightBulbProperties = {};
-    for (const [index, property] of propertiesArg.entries()) {
-      const value = result[index];
-      properties[property] = value === '' || value === undefined ? null : String(value);
-    }
-    this.emit({ type: 'properties', host: this.config.host, data: properties, timestamp: Date.now() });
-    return properties;
-  }
-
-  public async setLightState(patchArg: IYeelightLightStatePatch): Promise<void> {
-    const effect = patchArg.effect || this.config.effect || defaultEffect;
-    const transition = this.transitionValue(patchArg.transition);
-    if (patchArg.on !== undefined) {
-      await this.setPower(patchArg.on, effect, transition);
-    }
-    if (patchArg.colorTempKelvin !== undefined) {
-      await this.setColorTemp(patchArg.colorTempKelvin, effect, transition);
-    }
-    if (patchArg.rgbColor !== undefined) {
-      await this.setRgb(patchArg.rgbColor, effect, transition);
-    }
-    const brightness = patchArg.brightness ?? patchArg.percentage;
-    if (brightness !== undefined) {
-      await this.setBrightness(brightness, effect, transition);
-    }
-  }
-
-  public async setPower(onArg: boolean, effectArg = defaultEffect, durationArg = defaultTransition): Promise<void> {
-    await this.sendCommand({ method: 'set_power', params: [onArg ? 'on' : 'off', effectArg, durationArg] });
-  }
-
-  public async setBrightness(brightnessArg: number, effectArg = defaultEffect, durationArg = defaultTransition): Promise<void> {
-    await this.sendCommand({ method: 'set_bright', params: [this.clamp(Math.round(brightnessArg), 1, 100), effectArg, durationArg] });
-  }
-
-  public async setColorTemp(kelvinArg: number, effectArg = defaultEffect, durationArg = defaultTransition): Promise<void> {
-    await this.sendCommand({ method: 'set_ct_abx', params: [this.clamp(Math.round(kelvinArg), 1700, 6500), effectArg, durationArg] });
-  }
-
-  public async setRgb(rgbArg: [number, number, number], effectArg = defaultEffect, durationArg = defaultTransition): Promise<void> {
-    const [red, green, blue] = rgbArg.map((valueArg) => this.clamp(Math.round(valueArg), 0, 255));
-    await this.sendCommand({ method: 'set_rgb', params: [red * 65536 + green * 256 + blue, effectArg, durationArg] });
-  }
-
-  public async sendCommand(commandArg: IYeelightCommand): Promise<IYeelightCommandResponse> {
-    const command = {
-      ...commandArg,
-      id: commandArg.id ?? this.commandId++,
-      host: commandArg.host || this.config.host,
-      port: commandArg.port || this.config.port || defaultPort,
-      params: commandArg.params || [],
-    };
-    this.emit({ type: 'command', host: command.host, command, timestamp: Date.now() });
-    if (this.config.commandExecutor) {
-      return this.commandExecutorResponse(await this.config.commandExecutor(command), command);
-    }
-    if (!command.host) {
-      throw new Error('Yeelight live TCP commands require config.host. Snapshot/manual configs are read-only without commandExecutor.');
+    this.assertAdmitted();
+    if (typeof handlerArg !== 'function') throw new TypeError('Yeelight subscription requires a callback.');
+    if (this.eventHandlers.size >= 32) throw new Error('Yeelight subscription capacity reached.');
+    const id = Symbol();
+    this.eventHandlers.set(id, handlerArg);
+    return () => { this.eventHandlers.delete(id); };
+  }
+
+  public destroy(): Promise<void> {
+    if (!this.closePromise) {
+      this.lifetime.abort(new Error('Yeelight client is closed.'));
+      this.eventHandlers.clear();
+      this.unsubscribeProperties?.();
+      this.closePromise = Promise.allSettled([this.startPromise, this.operationTail, this.protocol?.close()]).then((resultsArg) => {
+        const close = resultsArg[2];
+        if (close.status === 'rejected') throw close.reason;
+      });
     }
-    return this.sendTcpCommand({ ...command, host: command.host });
-  }
-
-  public async destroy(): Promise<void> {
-    this.eventHandlers.clear();
+    return this.closePromise;
   }
 
-  private manualBulbs(): IYeelightBulbInfo[] {
-    const bulbs: IYeelightBulbInfo[] = [];
-    if (this.config.bulb) {
-      bulbs.push(this.config.bulb);
-    }
-    if (this.config.bulbs) {
-      bulbs.push(...this.config.bulbs);
-    }
-    if (this.config.devices) {
-      for (const [host, deviceConfig] of Object.entries(this.config.devices)) {
-        bulbs.push(this.bulbFromManualDevice(host, deviceConfig));
+  private async initialize(signalArg: AbortSignal): Promise<void> {
+    signalArg.throwIfAborted();
+    assertYeelightScope(this.configStore, this.config.homeId);
+    const advertisement = await plugins.ecobridgeDeviceManager.probeYeelight({
+      address: this.config.host, localAddress: this.config.localAddress, expectedId: this.config.expectedId,
+      discoveryPort: this.config.discoveryPort, timeoutMs: this.config.requestTimeoutMs, signal: signalArg,
+    });
+    signalArg.throwIfAborted();
+    assertYeelightScope(this.configStore, this.config.homeId);
+    if (!advertisement.supportedMethods.includes('get_prop')) throw new Error('Yeelight admission requires authoritative get_prop support.');
+    this.advertisement = advertisement;
+    this.protocol = new plugins.ecobridgeDeviceManager.YeelightProtocol({ address: advertisement.address, port: advertisement.port,
+      supportedMethods: advertisement.supportedMethods, connectTimeoutMs: this.config.requestTimeoutMs, requestTimeoutMs: this.config.requestTimeoutMs });
+    this.unsubscribeProperties = this.protocol.subscribeProperties((propertiesArg) => {
+      if (!this.snapshot || this.lifetime.signal.aborted || !properties.some((propertyArg) => propertiesArg[propertyArg] !== undefined)) return;
+      assertYeelightScope(this.configStore, this.config.homeId);
+      const previous = this.snapshot.bulbs[0].properties;
+      const merged: Record<string, string> = {};
+      for (const property of properties) {
+        const value = propertiesArg[property] ?? previous[property];
+        if (value !== undefined) merged[property] = value;
+      }
+      const parsed = parseYeelightProperties(merged);
+      this.snapshot = { ...this.snapshot, bulbs: [{ ...this.snapshot.bulbs[0], name: this.config.name ?? parsed.name ?? this.snapshot.bulbs[0].name, properties: parsed }], updatedAt: new Date().toISOString() };
+      for (const [id, handler] of [...this.eventHandlers]) {
+        if (this.lifetime.signal.aborted) break;
+        if (this.eventHandlers.has(id)) handler({ type: 'properties', snapshot: this.detachedSnapshot(), timestamp: Date.now() });
       }
-    }
-    if (!bulbs.length && this.config.host && (this.config.name || this.config.model || this.config.id)) {
-      bulbs.push(this.bulbFromConfig());
-    }
-    return bulbs;
-  }
-
-  private bulbFromManualDevice(hostArg: string, configArg: IYeelightManualDeviceConfig): IYeelightBulbInfo {
-    return {
-      id: configArg.id,
-      host: hostArg,
-      port: configArg.port || defaultPort,
-      name: configArg.name,
-      model: configArg.model || configArg.detectedModel || configArg.detected_model,
-      capabilities: configArg.capabilities,
-      properties: configArg.properties,
-      support: configArg.capabilities?.support?.split(' ').filter(Boolean),
-      available: false,
-    };
-  }
-
-  private bulbFromConfig(propertiesArg?: IYeelightBulbProperties): IYeelightBulbInfo {
-    return {
-      id: this.config.id,
-      host: this.config.host,
-      port: this.config.port || defaultPort,
-      name: this.config.name || propertiesArg?.name || undefined,
-      model: this.config.model || this.config.detectedModel || this.config.detected_model,
-      properties: propertiesArg,
-      available: Boolean(propertiesArg),
-    };
-  }
-
-  private async sendTcpCommand(commandArg: Required<Pick<IYeelightCommand, 'id' | 'method' | 'params' | 'host' | 'port'>>): Promise<IYeelightCommandResponse> {
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      let buffer = '';
-      const socket = plugins.net.createConnection({ host: commandArg.host, port: commandArg.port });
-      const timeout = setTimeout(() => {
-        finish(new Error(`Yeelight TCP command ${commandArg.method} timed out for ${commandArg.host}:${commandArg.port}.`));
-      }, 5000);
-
-      const finish = (errorArg?: Error, responseArg?: IYeelightCommandResponse) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        clearTimeout(timeout);
-        socket.removeAllListeners();
-        socket.destroy();
-        if (errorArg) {
-          this.emit({ type: 'error', host: commandArg.host, command: commandArg, error: errorArg.message, timestamp: Date.now() });
-          reject(errorArg);
-        } else {
-          resolve(responseArg || { id: commandArg.id, result: [] });
-        }
-      };
-
-      socket.on('connect', () => {
-        socket.write(`${JSON.stringify({ id: commandArg.id, method: commandArg.method, params: commandArg.params })}\r\n`);
-      });
-      socket.on('data', (chunkArg) => {
-        buffer += chunkArg.toString('utf8');
-        const lines = buffer.split(/\r?\n/);
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-          if (!line.trim()) {
-            continue;
-          }
-          const response = this.parseResponseLine(line);
-          if (!response) {
-            continue;
-          }
-          if (response.method === 'props') {
-            this.emit({ type: 'properties', host: commandArg.host, data: response.params, timestamp: Date.now() });
-            continue;
-          }
-          if (response.error) {
-            finish(new Error(`Yeelight command ${commandArg.method} failed: ${JSON.stringify(response.error)}`));
-            return;
-          }
-          finish(undefined, response);
-          return;
-        }
-      });
-      socket.on('error', (errorArg) => finish(errorArg));
-      socket.on('close', () => {
-        if (!settled) {
-          const response = this.parseResponseLine(buffer);
-          if (response && !response.error) {
-            finish(undefined, response);
-          } else {
-            finish(new Error(`Yeelight TCP connection closed before ${commandArg.method} response.`));
-          }
-        }
-      });
     });
+    await this.protocol.connect({ signal: signalArg, timeoutMs: this.config.requestTimeoutMs });
+    await this.read(signalArg);
   }
 
-  private parseResponseLine(lineArg: string): IYeelightCommandResponse | undefined {
+  private async read(signalArg: AbortSignal): Promise<void> {
+    signalArg.throwIfAborted();
+    assertYeelightScope(this.configStore, this.config.homeId);
+    const raw = await this.connectedProtocol().getProperties(properties, { signal: signalArg, timeoutMs: this.config.requestTimeoutMs });
+    signalArg.throwIfAborted();
+    assertYeelightScope(this.configStore, this.config.homeId);
     try {
-      return JSON.parse(lineArg) as IYeelightCommandResponse;
-    } catch {
-      return undefined;
-    }
-  }
-
-  private commandExecutorResponse(resultArg: unknown, commandArg: IYeelightCommand): IYeelightCommandResponse {
-    if (this.isCommandResponse(resultArg)) {
-      return resultArg;
-    }
-    if (this.isCommandResult(resultArg)) {
-      if (!resultArg.success) {
-        throw new Error(resultArg.error || `Yeelight command ${commandArg.method} failed.`);
-      }
-      return { id: commandArg.id, result: [resultArg.data ?? 'ok'] };
-    }
-    return { id: commandArg.id, result: [resultArg ?? 'ok'] };
-  }
-
-  private withEvents(snapshotArg: IYeelightSnapshot): IYeelightSnapshot {
-    return { ...snapshotArg, events: [...(snapshotArg.events || []), ...this.events] };
-  }
-
-  private emit(eventArg: IYeelightEvent): void {
-    this.events.push(eventArg);
-    for (const handler of this.eventHandlers) {
-      handler(eventArg);
-    }
-  }
-
-  private transitionValue(valueArg?: number): number {
-    if (typeof valueArg === 'number' && Number.isFinite(valueArg)) {
-      return Math.round(valueArg >= 0 && valueArg < 100 ? valueArg * 1000 : valueArg);
-    }
-    if (typeof this.config.transition === 'number' && Number.isFinite(this.config.transition)) {
-      return this.config.transition;
-    }
-    return defaultTransition;
-  }
-
-  private clamp(valueArg: number, minArg: number, maxArg: number): number {
-    return Math.min(maxArg, Math.max(minArg, valueArg));
-  }
-
-  private isCommandResponse(valueArg: unknown): valueArg is IYeelightCommandResponse {
-    return this.isRecord(valueArg) && ('result' in valueArg || 'error' in valueArg || 'method' in valueArg);
-  }
-
-  private isCommandResult(valueArg: unknown): valueArg is IYeelightCommandResult {
-    return this.isRecord(valueArg) && typeof valueArg.success === 'boolean';
+      const observed = parseYeelightProperties(raw);
+      const advertisement = this.advertisement;
+      if (!advertisement) throw new Error('Yeelight admission is missing.');
+      this.snapshot = { homeId: this.config.homeId, connected: true, updatedAt: new Date().toISOString(), bulbs: [{
+        id: advertisement.id, host: advertisement.address, port: advertisement.port, model: advertisement.model,
+        name: this.config.name ?? observed.name ?? `Yeelight ${advertisement.id}`,
+        fwVersion: advertisement.firmwareVersion, support: [...advertisement.supportedMethods], properties: observed, available: true,
+      }] };
+      this.needsReconciliation = false;
+    } catch (errorArg) {
+      this.lifetime.abort(errorArg);
+      this.eventHandlers.clear();
+      await this.protocol?.close();
+      throw errorArg;
+    }
+  }
+
+  private connectedProtocol(): plugins.ecobridgeDeviceManager.YeelightProtocol {
+    this.lifetime.signal.throwIfAborted();
+    if (!this.protocol?.isConnected) throw new Error('Yeelight TCP connection is not active.');
+    return this.protocol;
+  }
+
+  private assertAdmitted(): void {
+    this.lifetime.signal.throwIfAborted();
+    assertYeelightScope(this.configStore, this.config.homeId);
+    if (!this.isHealthy()) throw new Error('Yeelight bulb is unavailable.');
+  }
+
+  private detachedSnapshot(): IYeelightSnapshot {
+    if (!this.snapshot) throw new Error('Yeelight has no admitted observation.');
+    const snapshot = structuredClone(this.snapshot);
+    snapshot.connected = this.isHealthy();
+    snapshot.bulbs[0].available = snapshot.connected;
+    return snapshot;
+  }
+
+  private run<TResult>(operationArg: (signalArg: AbortSignal) => Promise<TResult>, signalArg?: AbortSignal): Promise<TResult> {
+    try { this.assertAdmitted(); signalArg?.throwIfAborted(); }
+    catch (errorArg) { return Promise.reject(errorArg); }
+    if (this.pendingOperations >= 16) return Promise.reject(new Error('Yeelight operation capacity reached.'));
+    const deadline = this.deadline(signalArg);
+    this.pendingOperations++;
+    let cancelWaiting: () => void = () => {};
+    const cancelledWhileWaiting = new Promise<never>((_resolveArg, rejectArg) => {
+      cancelWaiting = () => rejectArg(deadline.signal.reason);
+      deadline.signal.addEventListener('abort', cancelWaiting, { once: true });
+    });
+    const operation = this.operationTail.then(() => {
+      // Queued cancellation can refuse dispatch; an active effect retains the protocol's outcome.
+      deadline.signal.removeEventListener('abort', cancelWaiting);
+      deadline.signal.throwIfAborted();
+      this.assertAdmitted();
+      return operationArg(deadline.signal);
+    }).finally(() => {
+      deadline.signal.removeEventListener('abort', cancelWaiting);
+      this.pendingOperations--;
+      deadline.dispose();
+    });
+    this.operationTail = operation.then(() => {}, () => {});
+    if (deadline.signal.aborted) cancelWaiting();
+    return Promise.race([operation, cancelledWhileWaiting]);
   }
 
-  private isRecord(valueArg: unknown): valueArg is Record<string, unknown> {
-    return typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+  private deadline(signalArg?: AbortSignal): { signal: AbortSignal; dispose: () => void } {
+    if (signalArg !== undefined && !(signalArg instanceof AbortSignal)) throw new TypeError('Yeelight cancellation requires an AbortSignal.');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('Yeelight operation deadline expired.')), this.config.requestTimeoutMs);
+    timer.unref();
+    return { signal: AbortSignal.any([this.lifetime.signal, controller.signal, ...(signalArg ? [signalArg] : [])]), dispose: () => clearTimeout(timer) };
   }
 }

package/ts/integrations/yeelight/yeelight.classes.configflow.ts

@@ -1,46 +1,37 @@
 import type { IConfigFlow, IConfigFlowContext, IConfigFlowStep, IDiscoveryCandidate } from '../../core/types.js';
 import type { IYeelightConfig } from './yeelight.types.js';
-
-const defaultPort = 55443;
+import { YeelightClient } from './yeelight.classes.client.js';
+import { assertYeelightScope, normalizeYeelightConfig, yeelightRecord } from './yeelight.validation.js';
 
 export class YeelightConfigFlow implements IConfigFlow<IYeelightConfig> {
   public async start(candidateArg: IDiscoveryCandidate, contextArg: IConfigFlowContext): Promise<IConfigFlowStep<IYeelightConfig>> {
-    void contextArg;
     return {
-      kind: 'form',
-      title: 'Connect Yeelight',
-      description: 'Configure local LAN control for a Yeelight bulb. LAN control must be enabled on the bulb for live commands.',
+      kind: 'form', title: 'Connect Yeelight',
+      description: 'Enable LAN Control, select the home and local IPv4 interface, and confirm the vendor device ID. Discovery metadata is an unauthenticated setup hint.',
       fields: [
-        { name: 'host', label: 'Host', type: 'text', required: true },
-        { name: 'port', label: 'Port', type: 'number' },
-        { name: 'model', label: 'Model', type: 'text' },
-        { name: 'name', label: 'Name', type: 'text' },
+        { name: 'homeId', label: 'Home ID', type: 'text', required: true },
+        { name: 'host', label: 'Bulb IPv4 address', type: 'text', required: true },
+        { name: 'localAddress', label: 'Hub local IPv4 interface', type: 'text', required: true },
+        { name: 'expectedId', label: 'Expected Yeelight discovery ID', type: 'text', required: true },
+        { name: 'name', label: 'Display name', type: 'text' },
       ],
       submit: async (valuesArg) => {
-        const host = this.stringValue(valuesArg.host) || candidateArg.host;
-        if (!host) {
-          return { kind: 'error', title: 'Missing Yeelight host', error: 'Host is required for Yeelight local LAN control.' };
+        try {
+          const values = yeelightRecord(valuesArg, ['homeId', 'host', 'localAddress', 'expectedId', 'name', 'discoveryPort', 'requestTimeoutMs', 'effect', 'transitionMs']);
+          const config = normalizeYeelightConfig({
+            ...values, homeId: values.homeId, host: values.host ?? candidateArg.host,
+            localAddress: values.localAddress, expectedId: values.expectedId ?? candidateArg.id,
+            name: values.name,
+          });
+          assertYeelightScope(contextArg.configStore, config.homeId);
+          const client = new YeelightClient(config, contextArg.configStore);
+          try { await client.start(); }
+          finally { await client.destroy(); }
+          return { kind: 'done', title: 'Yeelight admission configured', config };
+        } catch {
+          return { kind: 'error', title: 'Invalid Yeelight admission', error: 'Provide matching home scope and local IPv4 addresses, enable LAN Control, and verify the expected device ID and authoritative state.' };
         }
-        return {
-          kind: 'done',
-          title: 'Yeelight configured',
-          config: {
-            host,
-            port: this.numberValue(valuesArg.port) || candidateArg.port || defaultPort,
-            model: this.stringValue(valuesArg.model) || candidateArg.model,
-            name: this.stringValue(valuesArg.name) || candidateArg.name,
-            id: candidateArg.id,
-          },
-        };
       },
     };
   }
-
-  private stringValue(valueArg: unknown): string | undefined {
-    return typeof valueArg === 'string' && valueArg.trim() ? valueArg.trim() : undefined;
-  }
-
-  private numberValue(valueArg: unknown): number | undefined {
-    return typeof valueArg === 'number' && Number.isFinite(valueArg) ? valueArg : undefined;
-  }
 }