Update flare-ui/src/app/services/environment.service.ts

flare-ui/src/app/services/environment.service.ts

@@ -1,25 +1,102 @@
+// environment.service.ts
+// Path: /flare-ui/src/app/services/environment.service.ts
+
 import { Injectable } from '@angular/core';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { BehaviorSubject, Observable, throwError } from 'rxjs';
 import { Environment } from './api.service';
 
+export interface EnvironmentError {
+  type: 'validation' | 'update' | 'unknown';
+  message: string;
+  details?: any;
+}
+
 @Injectable({
   providedIn: 'root'
 })
 export class EnvironmentService {
   private environmentSubject = new BehaviorSubject<Environment | null>(null);
   public environment$ = this.environmentSubject.asObservable();
+  
   private ttsEnabledSource = new BehaviorSubject<boolean>(false);
   private sttEnabledSource = new BehaviorSubject<boolean>(false);
   
+  private errorSubject = new BehaviorSubject<EnvironmentError | null>(null);
+  public error$ = this.errorSubject.asObservable();
+  
+  // Local storage keys
+  private readonly TTS_KEY = 'flare_tts_enabled';
+  private readonly STT_KEY = 'flare_stt_enabled';
+  
   ttsEnabled$ = this.ttsEnabledSource.asObservable();
   sttEnabled$ = this.sttEnabledSource.asObservable();
 
+  constructor() {
+    // Load saved preferences
+    this.loadPreferences();
+  }
+
+  private loadPreferences(): void {
+    try {
+      // Load TTS preference
+      const savedTTS = localStorage.getItem(this.TTS_KEY);
+      if (savedTTS !== null) {
+        this.ttsEnabledSource.next(savedTTS === 'true');
+      }
+      
+      // Load STT preference
+      const savedSTT = localStorage.getItem(this.STT_KEY);
+      if (savedSTT !== null) {
+        this.sttEnabledSource.next(savedSTT === 'true');
+      }
+    } catch (error) {
+      console.error('Error loading preferences:', error);
+      // Use defaults on error
+      this.ttsEnabledSource.next(false);
+      this.sttEnabledSource.next(false);
+    }
+  }
+
   setTTSEnabled(enabled: boolean): void {
-    this.ttsEnabledSource.next(enabled);
+    try {
+      if (typeof enabled !== 'boolean') {
+        throw new Error('TTS enabled must be a boolean value');
+      }
+      
+      this.ttsEnabledSource.next(enabled);
+      
+      // Save preference
+      try {
+        localStorage.setItem(this.TTS_KEY, enabled.toString());
+      } catch (error) {
+        console.warn('Failed to save TTS preference:', error);
+      }
+      
+      console.log(`TTS ${enabled ? 'enabled' : 'disabled'}`);
+    } catch (error) {
+      this.handleError('validation', 'Invalid TTS setting', error);
+    }
   }
 
   setSTTEnabled(enabled: boolean): void {
-    this.sttEnabledSource.next(enabled);
+    try {
+      if (typeof enabled !== 'boolean') {
+        throw new Error('STT enabled must be a boolean value');
+      }
+      
+      this.sttEnabledSource.next(enabled);
+      
+      // Save preference
+      try {
+        localStorage.setItem(this.STT_KEY, enabled.toString());
+      } catch (error) {
+        console.warn('Failed to save STT preference:', error);
+      }
+      
+      console.log(`STT ${enabled ? 'enabled' : 'disabled'}`);
+    } catch (error) {
+      this.handleError('validation', 'Invalid STT setting', error);
+    }
   }
 
   isTTSEnabled(): boolean {
@@ -30,8 +107,35 @@ export class EnvironmentService {
     return this.sttEnabledSource.value;
   }
   
-  updateEnvironment(env: Environment) {
-    this.environmentSubject.next(env);
+  updateEnvironment(env: Environment | null): void {
+    try {
+      if (env) {
+        // Validate environment object
+        this.validateEnvironment(env);
+        
+        // Check for changes
+        const currentEnv = this.environmentSubject.value;
+        const hasChanged = !currentEnv || 
+                          currentEnv.id !== env.id || 
+                          currentEnv.work_mode !== env.work_mode ||
+                          currentEnv.last_update_date !== env.last_update_date;
+        
+        if (hasChanged) {
+          console.log('Environment updated:', {
+            id: env.id,
+            name: env.name,
+            work_mode: env.work_mode,
+            version: env.active_version_id
+          });
+        }
+      }
+      
+      this.environmentSubject.next(env);
+      this.errorSubject.next(null); // Clear any previous errors
+      
+    } catch (error: any) {
+      this.handleError('update', error.message || 'Failed to update environment', error);
+    }
   }
 
   getEnvironment(): Environment | null {
@@ -39,7 +143,147 @@ export class EnvironmentService {
   }
 
   isGPTMode(): boolean {
+    try {
+      const env = this.environmentSubject.value;
+      return env?.work_mode?.toLowerCase()?.startsWith('gpt4o') || false;
+    } catch (error) {
+      console.error('Error checking GPT mode:', error);
+      return false;
+    }
+  }
+
+  getWorkMode(): string | null {
     const env = this.environmentSubject.value;
-    return env?.work_mode?.startsWith('gpt4o') || false;
+    return env?.work_mode || null;
+  }
+
+  isEnvironmentActive(): boolean {
+    const env = this.environmentSubject.value;
+    return env?.enabled === true;
+  }
+
+  hasActiveVersion(): boolean {
+    const env = this.environmentSubject.value;
+    return !!env?.active_version_id;
+  }
+
+  // Check if environment supports a specific feature
+  supportsFeature(feature: 'tts' | 'stt' | 'realtime' | 'streaming'): boolean {
+    const env = this.environmentSubject.value;
+    if (!env) return false;
+    
+    switch (feature) {
+      case 'tts':
+        return this.isTTSEnabled() && env.enabled;
+      case 'stt':
+        return this.isSTTEnabled() && env.enabled;
+      case 'realtime':
+        return this.isGPTMode() && env.enabled;
+      case 'streaming':
+        return env.enabled;
+      default:
+        return false;
+    }
+  }
+
+  // Reset all settings
+  reset(): void {
+    try {
+      this.environmentSubject.next(null);
+      this.setTTSEnabled(false);
+      this.setSTTEnabled(false);
+      this.errorSubject.next(null);
+      
+      // Clear saved preferences
+      try {
+        localStorage.removeItem(this.TTS_KEY);
+        localStorage.removeItem(this.STT_KEY);
+      } catch (error) {
+        console.warn('Failed to clear preferences:', error);
+      }
+      
+      console.log('Environment service reset');
+    } catch (error) {
+      this.handleError('unknown', 'Failed to reset environment', error);
+    }
+  }
+
+  // Get configuration summary
+  getConfigSummary(): {
+    environment: string | null;
+    workMode: string | null;
+    ttsEnabled: boolean;
+    sttEnabled: boolean;
+    features: string[];
+  } {
+    const env = this.environmentSubject.value;
+    const features: string[] = [];
+    
+    if (this.supportsFeature('tts')) features.push('TTS');
+    if (this.supportsFeature('stt')) features.push('STT');
+    if (this.supportsFeature('realtime')) features.push('Realtime');
+    if (this.supportsFeature('streaming')) features.push('Streaming');
+    
+    return {
+      environment: env?.name || null,
+      workMode: env?.work_mode || null,
+      ttsEnabled: this.isTTSEnabled(),
+      sttEnabled: this.isSTTEnabled(),
+      features
+    };
+  }
+
+  private validateEnvironment(env: Environment): void {
+    if (!env.id) {
+      throw new Error('Environment must have an ID');
+    }
+    
+    if (!env.name || env.name.trim().length === 0) {
+      throw new Error('Environment must have a name');
+    }
+    
+    if (!env.project_id) {
+      throw new Error('Environment must be associated with a project');
+    }
+    
+    if (env.work_mode && !this.isValidWorkMode(env.work_mode)) {
+      throw new Error(`Invalid work mode: ${env.work_mode}`);
+    }
+  }
+
+  private isValidWorkMode(workMode: string): boolean {
+    const validModes = ['stream', 'batch', 'gpt4o', 'gpt4o-mini', 'gpt4o-realtime'];
+    return validModes.includes(workMode.toLowerCase());
+  }
+
+  private handleError(type: EnvironmentError['type'], message: string, details?: any): void {
+    const error: EnvironmentError = {
+      type,
+      message,
+      details
+    };
+    
+    console.error(`Environment error [${type}]:`, message, details);
+    this.errorSubject.next(error);
+  }
+
+  // Observable to check if environment is ready
+  isReady(): Observable<boolean> {
+    return new Observable(subscriber => {
+      const sub = this.environment$.subscribe(env => {
+        subscriber.next(!!env && env.enabled && !!env.active_version_id);
+      });
+      
+      return () => sub.unsubscribe();
+    });
+  }
+
+  // Get error state
+  hasError(): boolean {
+    return this.errorSubject.value !== null;
+  }
+
+  clearError(): void {
+    this.errorSubject.next(null);
   }
 }