tas-uell-sdk 0.0.5 → 0.1.0

package/esm2020/lib/services/tas.service.mjs

@@ -1,12 +1,12 @@
-import { Injectable, Inject } from "@angular/core";
-import { BehaviorSubject } from "rxjs";
-import { catchError, map } from "rxjs/operators";
-import * as OT from "@opentok/client";
-import { CallState, ViewMode, } from "../interfaces/tas.interfaces";
-import { TAS_CONFIG, TAS_HTTP_CLIENT } from "../config/tas.config";
+import { Injectable, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import * as OT from '@opentok/client';
+import { UserCallAction, RoomUserStatus, TasBusinessRole, TasUserRole, CallState, ViewMode, } from '../interfaces/tas.interfaces';
+import { TAS_CONFIG, TAS_HTTP_CLIENT, } from '../config/tas.config';
 import * as i0 from "@angular/core";
 // Re-export enums for backward compatibility
-export { CallState, ViewMode };
+export { CallState, ViewMode, TasBusinessRole, UserCallAction, RoomUserStatus };
 export class TasService {
     constructor(httpClient, config) {
         this.httpClient = httpClient;
@@ -23,6 +23,86 @@ export class TasService {
         // Session info for PiP mode restoration
         this.currentSessionId = null;
         this.currentToken = null;
+        this.STORAGE_KEY = 'tas_session_state';
+        this.DISCONNECTED_FLAG_KEY = 'tas_session_disconnected';
+        this.isFinishingSession = false;
+        // Proxy-video circuit state
+        this.proxyVideoSessionId = null;
+        this.proxyVideoToken = null;
+        this.currentBusinessRole = TasBusinessRole.USER;
+        // Waiting room and status polling
+        this.waitingRoomUsersSubject = new BehaviorSubject([]);
+        this.waitingRoomUsers$ = this.waitingRoomUsersSubject.asObservable();
+        this.ownerHasJoinedSubject = new BehaviorSubject(false);
+        this.ownerHasJoined$ = this.ownerHasJoinedSubject.asObservable();
+        // Observable that emits true when owner was present but then left
+        this.ownerHasLeftSubject = new BehaviorSubject(false);
+        this.ownerHasLeft$ = this.ownerHasLeftSubject.asObservable();
+        this.joinableSubject = new BehaviorSubject(false);
+        this.joinable$ = this.joinableSubject.asObservable();
+        // Observable for when backend requests geolocation activation
+        this.activateGeoSubject = new BehaviorSubject(false);
+        this.activateGeo$ = this.activateGeoSubject.asObservable();
+        // Observable for when geo request is active (owner waiting for user response)
+        this.geoRequestActiveSubject = new BehaviorSubject(false);
+        this.geoRequestActive$ = this.geoRequestActiveSubject.asObservable();
+        // Observable for when all geo has been granted
+        this.allGeoGrantedSubject = new BehaviorSubject(false);
+        this.allGeoGranted$ = this.allGeoGrantedSubject.asObservable();
+        this.statusPollingInterval = null;
+        this.DEFAULT_POLL_INTERVAL_MS = 30000; // Default 30s
+        this.wasOwnerPresent = false;
+        // Current call context
+        this.currentAppointmentId = null;
+        this.currentVideoCallId = null;
+        this.currentTenant = null;
+    }
+    // ... (Getters and other methods remain unchanged)
+    /**
+     * Start automatic status polling for the current session.
+     * Status is polled every intervalMs (default 30s).
+     */
+    startStatusPolling(params, intervalMs = this.DEFAULT_POLL_INTERVAL_MS) {
+        this.stopStatusPolling(); // Clear any existing polling
+        // Store context for polling
+        if (params.sessionId) {
+            this.currentSessionId = params.sessionId;
+        }
+        if (params.appointmentId) {
+            this.currentAppointmentId = params.appointmentId;
+        }
+        if (params.tenant) {
+            this.currentTenant = params.tenant;
+        }
+        console.log(`[TAS DEBUG] Starting status polling with interval ${intervalMs}ms`);
+        // Initial status fetch
+        this.fetchAndProcessStatus(params);
+        // Set up periodic polling
+        this.statusPollingInterval = setInterval(() => {
+            this.fetchAndProcessStatus(params);
+        }, intervalMs);
+    }
+    /**
+     * Stop automatic status polling.
+     */
+    stopStatusPolling() {
+        if (this.statusPollingInterval) {
+            clearInterval(this.statusPollingInterval);
+            this.statusPollingInterval = null;
+        }
+        // Do NOT reset waiting room state here, as other components might observe it
+    }
+    /**
+     * Reset polling state (waiting room, owner status, etc)
+     * Call this when completely exiting the flow
+     */
+    resetPollingState() {
+        this.stopStatusPolling();
+        this.waitingRoomUsersSubject.next([]);
+        this.ownerHasJoinedSubject.next(false);
+        this.ownerHasLeftSubject.next(false);
+        this.joinableSubject.next(false);
+        this.wasOwnerPresent = false;
     }
     // Getters
     get currentSession() {
@@ -40,18 +120,36 @@ export class TasService {
     get token() {
         return this.currentToken;
     }
+    get proxySessionId() {
+        return this.proxyVideoSessionId;
+    }
+    get proxyToken() {
+        return this.proxyVideoToken;
+    }
+    get businessRole() {
+        return this.currentBusinessRole;
+    }
     get isMuted() {
         return this.isMutedSubject.getValue();
     }
     // View Mode Methods
     setViewMode(mode) {
         this.viewModeSubject.next(mode);
+        if (this.currentSessionId && this.currentToken) {
+            this.saveSessionState(this.currentSessionId, this.currentToken, mode, this.currentBusinessRole);
+        }
     }
     enterPipMode() {
         this.viewModeSubject.next(ViewMode.PIP);
+        if (this.currentSessionId && this.currentToken) {
+            this.saveSessionState(this.currentSessionId, this.currentToken, ViewMode.PIP, this.currentBusinessRole);
+        }
     }
     exitPipMode() {
         this.viewModeSubject.next(ViewMode.FULLSCREEN);
+        if (this.currentSessionId && this.currentToken) {
+            this.saveSessionState(this.currentSessionId, this.currentToken, ViewMode.FULLSCREEN, this.currentBusinessRole);
+        }
     }
     isPipMode() {
         return this.viewModeSubject.getValue() === ViewMode.PIP;
@@ -78,7 +176,17 @@ export class TasService {
         }
     }
     // Session Management
-    disconnectSession() {
+    disconnectSession(clearStorage = true) {
+        console.log('[TAS DEBUG] TasService.disconnectSession called. clearStorage:', clearStorage);
+        // Call finishSession before disconnecting if we have a sessionId
+        const sessionIdToFinish = this.currentSessionId;
+        // Clear storage FIRST to prevent any race conditions where state might be saved after disconnect
+        if (clearStorage) {
+            this.clearSessionState();
+            // Set a flag to indicate this session was intentionally disconnected
+            // This prevents reconnection on page reload
+            sessionStorage.setItem(this.DISCONNECTED_FLAG_KEY, 'true');
+        }
         if (this.session) {
             this.session.disconnect();
             this.session = null;
@@ -87,49 +195,288 @@ export class TasService {
         this.subscribers = [];
         this.currentSessionId = null;
         this.currentToken = null;
+        this.proxyVideoSessionId = null;
+        this.proxyVideoToken = null;
         this.isMutedSubject.next(false); // Reset mute state
         this.viewModeSubject.next(ViewMode.FULLSCREEN);
         this.callStateSubject.next(CallState.DISCONNECTED);
+        // Call proxy finish after disconnecting (only if not already finishing)
+        if (sessionIdToFinish && !this.isFinishingSession) {
+            this.isFinishingSession = true;
+            this.finishProxyVideoSession({
+                sessionId: sessionIdToFinish,
+                businessRole: this.currentBusinessRole,
+            }).subscribe({
+                next: (response) => {
+                    console.log('[TAS DEBUG] Session finished successfully:', response);
+                    this.isFinishingSession = false;
+                },
+                error: (error) => {
+                    console.error('[TAS DEBUG] Error finishing session:', error);
+                    this.isFinishingSession = false;
+                },
+            });
+        }
     }
     isCallActive() {
         return this.callStateSubject.getValue() === CallState.CONNECTED;
     }
+    // State Persistence
+    saveSessionState(sessionId, token, viewMode, businessRole = TasBusinessRole.USER) {
+        const state = {
+            sessionId,
+            token,
+            viewMode,
+            businessRole,
+        };
+        sessionStorage.setItem(this.STORAGE_KEY, JSON.stringify(state));
+    }
+    clearSessionState() {
+        sessionStorage.removeItem(this.STORAGE_KEY);
+        // Also clear the disconnected flag when clearing state
+        sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);
+    }
+    canRestoreSession() {
+        return !!sessionStorage.getItem(this.STORAGE_KEY);
+    }
+    restoreSession(containerId) {
+        const savedState = sessionStorage.getItem(this.STORAGE_KEY);
+        if (!savedState)
+            return;
+        // Check if this session was intentionally disconnected
+        // If so, don't restore it on page reload
+        const wasDisconnected = sessionStorage.getItem(this.DISCONNECTED_FLAG_KEY);
+        if (wasDisconnected === 'true') {
+            console.log('[TAS DEBUG] Session was intentionally disconnected, skipping restore');
+            this.clearSessionState();
+            sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);
+            return;
+        }
+        // Don't restore if we're already disconnected or if there's no active session
+        // This prevents restoring sessions that were properly disconnected
+        if (this.callStateSubject.getValue() === CallState.DISCONNECTED) {
+            console.log('[TAS DEBUG] Call state is DISCONNECTED, skipping restore');
+            this.clearSessionState();
+            return;
+        }
+        try {
+            const state = JSON.parse(savedState);
+            if (state.sessionId && state.token) {
+                console.log('[TAS DEBUG] Restoring session from storage');
+                // Force PiP mode for restoration to ensure UI consistency
+                this.viewModeSubject.next(ViewMode.PIP);
+                if (state.businessRole) {
+                    this.currentBusinessRole = state.businessRole;
+                }
+                this.connectSession(state.sessionId, state.token, containerId, // Use the same container for both since we are in PiP
+                containerId, this.currentBusinessRole)
+                    .then(() => {
+                    console.log('[TAS DEBUG] Session restored successfully');
+                    // Clear the disconnected flag if restoration succeeds
+                    sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);
+                })
+                    .catch((err) => {
+                    console.error('[TAS DEBUG] Failed to restore session:', err);
+                    this.clearSessionState(); // Clear bad state
+                });
+            }
+        }
+        catch (e) {
+            console.error('[TAS DEBUG] Error parsing saved session state', e);
+            this.clearSessionState();
+        }
+    }
     // API Methods
-    createRoom(payload) {
-        return this.httpClient.post("v2/room", { body: payload, headers: {} }).pipe(map((response) => response), catchError((error) => {
-            console.error("TAS Service: createRoom failed", error);
+    /**
+     * PROXY circuit token: /v2/proxy/video/start
+     */
+    startProxyVideoSession(payload) {
+        return this.httpClient
+            .post('v2/proxy/video/start', {
+            body: payload,
+            headers: {},
+        })
+            .pipe(map((response) => response), catchError((error) => {
+            console.error('TAS Service: startProxyVideoSession failed', error);
             throw error;
         }));
     }
-    generateToken(payload) {
-        return this.httpClient.post("v2/room/token", { body: payload, headers: {} }).pipe(map((response) => response), catchError((error) => {
-            console.error("TAS Service: generateToken failed", error);
+    /**
+     * PROXY circuit status: /v2/proxy/video/status
+     */
+    getProxyVideoStatus(payload) {
+        return this.httpClient
+            .post('v2/proxy/video/status', {
+            body: payload,
+            headers: {},
+        })
+            .pipe(map((response) => response), catchError((error) => {
+            console.error('TAS Service: getProxyVideoStatus failed', error);
             throw error;
         }));
     }
+    /**
+     * PROXY circuit user modification: /v2/proxy/video/user/modify
+     */
+    modifyProxyVideoUser(payload) {
+        return this.httpClient
+            .patch('v2/proxy/video/user/modify', {
+            body: payload,
+            headers: {},
+        })
+            .pipe(catchError((error) => {
+            console.error('TAS Service: modifyProxyVideoUser failed', error);
+            throw error;
+        }));
+    }
+    finishProxyVideoSession(payload) {
+        return this.httpClient
+            .post('v2/proxy/video/finish', {
+            body: payload,
+            headers: {},
+        })
+            .pipe(map((response) => response), catchError((error) => {
+            console.error('TAS Service: finishProxyVideoSession failed', error);
+            throw error;
+        }));
+    }
+    /**
+     * Get user appointments within a date range.
+     * @param params Date range for querying appointments
+     * @returns Observable of appointment array
+     */
+    getAppointments(params) {
+        return this.httpClient
+            .get(`v2/proxy/appointment/agendas/user/appointments?fromDate=${params.fromDate}&toDate=${params.toDate}`, { headers: {} })
+            .pipe(catchError((error) => {
+            console.error('TAS Service: getAppointments failed', error);
+            throw error;
+        }));
+    }
+    /**
+     * Start automatic status polling for the current session.
+     * Status is polled every STATUS_POLL_INTERVAL_MS milliseconds.
+     */
+    /**
+     * Stop automatic status polling.
+     */
+    /**
+     * Fetch status and process the response.
+     */
+    fetchAndProcessStatus(params) {
+        this.getProxyVideoStatus(params).subscribe({
+            next: (response) => {
+                this.processStatusResponse(response);
+            },
+            error: (err) => {
+                console.error('[TAS DEBUG] Status polling error:', err);
+            },
+        });
+    }
+    /**
+     * Process status response to update waiting room users and owner join status.
+     */
+    processStatusResponse(response) {
+        const content = response.content;
+        // Update videoCallId if available
+        if (content.videoCallId) {
+            this.currentVideoCallId = content.videoCallId;
+        }
+        // Update sessionId if available
+        if (content.sessionId) {
+            this.currentSessionId = content.sessionId;
+            this.proxyVideoSessionId = content.sessionId;
+        }
+        // Update joinable status
+        this.joinableSubject.next(content.joinable);
+        // Update activateGeo status
+        if (content.activateGeo !== undefined) {
+            console.log('[TAS DEBUG] activateGeo received:', content.activateGeo);
+            this.activateGeoSubject.next(content.activateGeo);
+        }
+        // Update geoRequestActive status (owner waiting for user geo response)
+        if (content.geoRequestActive !== undefined) {
+            console.log('[TAS DEBUG] geoRequestActive received:', content.geoRequestActive);
+            this.geoRequestActiveSubject.next(content.geoRequestActive);
+        }
+        // Update allGeoGranted status (all users responded with geo)
+        if (content.allGeoGranted !== undefined) {
+            console.log('[TAS DEBUG] allGeoGranted received:', content.allGeoGranted);
+            this.allGeoGrantedSubject.next(content.allGeoGranted);
+        }
+        // Check if owner has joined
+        const ownerJoined = this.checkIfOwnerJoined(content.users);
+        this.ownerHasJoinedSubject.next(ownerJoined);
+        // Detect if owner left: was present, now not present
+        if (this.wasOwnerPresent && !ownerJoined) {
+            console.log('[TAS DEBUG] Owner has left the session');
+            this.ownerHasLeftSubject.next(true);
+        }
+        if (ownerJoined) {
+            this.wasOwnerPresent = true;
+        }
+        // Extract waiting room users (status === WAITING)
+        const waitingUsers = content.users
+            .filter((u) => u.status === 'WAITING')
+            .map((u) => ({
+            userId: u.userId,
+            name: `User ${u.userId}`,
+            status: RoomUserStatus.WAITING,
+        }));
+        this.waitingRoomUsersSubject.next(waitingUsers);
+    }
+    /**
+     * Check if at least one OWNER has joined the call.
+     */
+    checkIfOwnerJoined(users) {
+        return users.some((u) => u.rol === TasUserRole.OWNER && u.status === 'JOINED');
+    }
+    /**
+     * Admit a user from the waiting room by changing their status.
+     */
+    admitUserFromWaitingRoom(userId, videoCallId) {
+        return this.modifyProxyVideoUser({
+            userId,
+            videoCallId,
+            action: UserCallAction.WAITING_ROOM_LEAVE,
+        });
+    }
+    // Getters for current call context
+    get appointmentId() {
+        return this.currentAppointmentId;
+    }
+    get videoCallId() {
+        return this.currentVideoCallId;
+    }
     /**
      * Connects to a TokBox video session
      */
-    connectSession(sessionId, token, publisherElement, subscriberElement) {
+    connectSession(sessionId, token, publisherElement, subscriberElement, businessRole = TasBusinessRole.USER) {
         this.callStateSubject.next(CallState.CONNECTING);
         this.currentSessionId = sessionId;
         this.currentToken = token;
+        this.currentBusinessRole = businessRole;
+        this.isFinishingSession = false; // Reset flag for new session
+        // Save initial state (defaulting to current view mode)
+        this.saveSessionState(sessionId, token, this.viewModeSubject.getValue(), businessRole);
+        // Clear the disconnected flag when starting a new connection
+        sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);
         return new Promise((resolve, reject) => {
             if (!OT.checkSystemRequirements()) {
                 this.callStateSubject.next(CallState.ERROR);
-                reject(new Error("Browser not compatible with TokBox"));
+                reject(new Error('Browser not compatible with TokBox'));
                 return;
             }
             this.session = OT.initSession(this.config.tokBoxApiKey, sessionId);
             // Handle new streams (remote participants joining)
-            this.session.on("streamCreated", (event) => {
+            this.session.on('streamCreated', (event) => {
                 const subscriber = this.session?.subscribe(event.stream, subscriberElement, {
-                    insertMode: "append",
-                    width: "100%",
-                    height: "100%",
+                    insertMode: 'append',
+                    width: '100%',
+                    height: '100%',
                 }, (error) => {
                     if (error) {
-                        console.error("Error subscribing to stream:", error);
+                        console.error('Error subscribing to stream:', error);
                     }
                 });
                 if (subscriber) {
@@ -137,29 +484,48 @@ export class TasService {
                 }
             });
             // Handle streams ending (remote participants leaving)
-            this.session.on("streamDestroyed", (event) => {
+            this.session.on('streamDestroyed', (event) => {
                 this.subscribers = this.subscribers.filter((sub) => sub.stream?.streamId !== event.stream.streamId);
             });
             // Handle session disconnection
-            this.session.on("sessionDisconnected", () => {
+            this.session.on('sessionDisconnected', () => {
                 this.callStateSubject.next(CallState.DISCONNECTED);
+                // Call finishSession when session is disconnected (e.g., by server)
+                // Only call if not already finishing (prevents duplicate calls)
+                const sessionIdToFinish = this.currentSessionId;
+                if (sessionIdToFinish && !this.isFinishingSession) {
+                    this.isFinishingSession = true;
+                    this.finishProxyVideoSession({
+                        sessionId: sessionIdToFinish,
+                        businessRole: this.currentBusinessRole,
+                    }).subscribe({
+                        next: (response) => {
+                            console.log('[TAS DEBUG] Session finished on disconnect event:', response);
+                            this.isFinishingSession = false;
+                        },
+                        error: (error) => {
+                            console.error('[TAS DEBUG] Error finishing session on disconnect:', error);
+                            this.isFinishingSession = false;
+                        },
+                    });
+                }
             });
             // Connect to session
             this.session.connect(token, (error) => {
                 if (error) {
-                    console.error("Error connecting to session:", error);
+                    console.error('Error connecting to session:', error);
                     this.callStateSubject.next(CallState.ERROR);
                     reject(error);
                     return;
                 }
                 // Initialize publisher (local video)
                 this.publisher = OT.initPublisher(publisherElement, {
-                    insertMode: "append",
-                    width: "100%",
-                    height: "100%",
+                    insertMode: 'append',
+                    width: '100%',
+                    height: '100%',
                 }, (err) => {
                     if (err) {
-                        console.error("Error initializing publisher:", err);
+                        console.error('Error initializing publisher:', err);
                         this.callStateSubject.next(CallState.ERROR);
                         reject(err);
                         return;
@@ -167,7 +533,7 @@ export class TasService {
                     // Publish to session
                     this.session?.publish(this.publisher, (pubErr) => {
                         if (pubErr) {
-                            console.error("Error publishing stream:", pubErr);
+                            console.error('Error publishing stream:', pubErr);
                             this.callStateSubject.next(CallState.ERROR);
                             reject(pubErr);
                         }
@@ -227,12 +593,12 @@ export class TasService {
         this.movePublisherTo('publisher-container');
     }
 }
-TasService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasService, deps: [{ token: TAS_HTTP_CLIENT }, { token: TAS_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
-TasService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasService, providedIn: "root" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasService, decorators: [{
+TasService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: TasService, deps: [{ token: TAS_HTTP_CLIENT }, { token: TAS_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable });
+TasService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: TasService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: TasService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: "root",
+                    providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: undefined, decorators: [{
                     type: Inject,
@@ -241,4 +607,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                     type: Inject,
                     args: [TAS_CONFIG]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tas.service.js","sourceRoot":"","sources":["../../../../../projects/tas-uell-sdk/src/lib/services/tas.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from \"@angular/core\";\nimport { BehaviorSubject, Observable } from \"rxjs\";\nimport { catchError, map } from \"rxjs/operators\";\nimport * as OT from \"@opentok/client\";\nimport {\n\tCreateRoomRequest,\n\tCreateRoomResponse,\n\tGenerateTokenRequest,\n\tGenerateTokenResponse,\n\tCallState,\n\tViewMode,\n} from \"../interfaces/tas.interfaces\";\nimport { TAS_CONFIG, TAS_HTTP_CLIENT, TasConfig, TasHttpClient } from \"../config/tas.config\";\n\n// Re-export enums for backward compatibility\nexport { CallState, ViewMode };\n\n@Injectable({\n\tprovidedIn: \"root\",\n})\nexport class TasService {\n\tprivate session: OT.Session | null = null;\n\tprivate publisher: OT.Publisher | null = null;\n\tprivate subscribers: OT.Subscriber[] = [];\n\n\tprivate callStateSubject = new BehaviorSubject<CallState>(CallState.IDLE);\n\tpublic callState$ = this.callStateSubject.asObservable();\n\n\tprivate viewModeSubject = new BehaviorSubject<ViewMode>(ViewMode.FULLSCREEN);\n\tpublic viewMode$ = this.viewModeSubject.asObservable();\n\n\tprivate isMutedSubject = new BehaviorSubject<boolean>(false);\n\tpublic isMuted$ = this.isMutedSubject.asObservable();\n\n\t// Session info for PiP mode restoration\n\tprivate currentSessionId: string | null = null;\n\tprivate currentToken: string | null = null;\n\n\tconstructor(\n\t\t@Inject(TAS_HTTP_CLIENT) private httpClient: TasHttpClient,\n\t\t@Inject(TAS_CONFIG) private config: TasConfig\n\t) {}\n\n\t// Getters\n\tpublic get currentSession(): OT.Session | null {\n\t\treturn this.session;\n\t}\n\n\tpublic get currentPublisher(): OT.Publisher | null {\n\t\treturn this.publisher;\n\t}\n\n\tpublic get currentSubscribers(): OT.Subscriber[] {\n\t\treturn this.subscribers;\n\t}\n\n\tpublic get sessionId(): string | null {\n\t\treturn this.currentSessionId;\n\t}\n\n\tpublic get token(): string | null {\n\t\treturn this.currentToken;\n\t}\n\n\tpublic get isMuted(): boolean {\n\t\treturn this.isMutedSubject.getValue();\n\t}\n\n\t// View Mode Methods\n\tpublic setViewMode(mode: ViewMode): void {\n\t\tthis.viewModeSubject.next(mode);\n\t}\n\n\tpublic enterPipMode(): void {\n\t\tthis.viewModeSubject.next(ViewMode.PIP);\n\t}\n\n\tpublic exitPipMode(): void {\n\t\tthis.viewModeSubject.next(ViewMode.FULLSCREEN);\n\t}\n\n\tpublic isPipMode(): boolean {\n\t\treturn this.viewModeSubject.getValue() === ViewMode.PIP;\n\t}\n\n\t// Audio Control\n\tpublic toggleMute(): void {\n\t\tif (this.publisher) {\n\t\t\tconst newMuteState = !this.isMutedSubject.getValue();\n\t\t\tconst shouldEnableAudio = !newMuteState;\n\t\t\t\n\t\t\t// Use OpenTok's publishAudio\n\t\t\tthis.publisher.publishAudio(shouldEnableAudio);\n\t\t\t\n\t\t\t// Also directly control the MediaStreamTrack as backup\n\t\t\tconst audioTrack = this.publisher.getAudioSource?.();\n\t\t\tif (audioTrack) {\n\t\t\t\taudioTrack.enabled = shouldEnableAudio;\n\t\t\t}\n\t\t\t\n\t\t\tthis.isMutedSubject.next(newMuteState);\n\t\t}\n\t}\n\n\tpublic setMute(muted: boolean): void {\n\t\tif (this.publisher) {\n\t\t\tthis.publisher.publishAudio(!muted);\n\t\t\tthis.isMutedSubject.next(muted);\n\t\t}\n\t}\n\n\t// Session Management\n\tpublic disconnectSession(): void {\n\t\tif (this.session) {\n\t\t\tthis.session.disconnect();\n\t\t\tthis.session = null;\n\t\t}\n\t\tthis.publisher = null;\n\t\tthis.subscribers = [];\n\t\tthis.currentSessionId = null;\n\t\tthis.currentToken = null;\n\t\tthis.isMutedSubject.next(false); // Reset mute state\n\t\tthis.viewModeSubject.next(ViewMode.FULLSCREEN);\n\t\tthis.callStateSubject.next(CallState.DISCONNECTED);\n\t}\n\n\tpublic isCallActive(): boolean {\n\t\treturn this.callStateSubject.getValue() === CallState.CONNECTED;\n\t}\n\n\t// API Methods\n\tpublic createRoom(payload: CreateRoomRequest): Observable<CreateRoomResponse> {\n\t\treturn this.httpClient.post<CreateRoomResponse>(\"v2/room\", { body: payload, headers: {} }).pipe(\n\t\t\tmap((response) => response as CreateRoomResponse),\n\t\t\tcatchError((error) => {\n\t\t\t\tconsole.error(\"TAS Service: createRoom failed\", error);\n\t\t\t\tthrow error;\n\t\t\t})\n\t\t);\n\t}\n\n\tpublic generateToken(payload: GenerateTokenRequest): Observable<GenerateTokenResponse> {\n\t\treturn this.httpClient.post<GenerateTokenResponse>(\"v2/room/token\", { body: payload, headers: {} }).pipe(\n\t\t\tmap((response: any) => response as GenerateTokenResponse),\n\t\t\tcatchError((error) => {\n\t\t\t\tconsole.error(\"TAS Service: generateToken failed\", error);\n\t\t\t\tthrow error;\n\t\t\t})\n\t\t);\n\t}\n\n\t/**\n\t * Connects to a TokBox video session\n\t */\n\tpublic connectSession(\n\t\tsessionId: string,\n\t\ttoken: string,\n\t\tpublisherElement: string,\n\t\tsubscriberElement: string\n\t): Promise<void> {\n\t\tthis.callStateSubject.next(CallState.CONNECTING);\n\t\tthis.currentSessionId = sessionId;\n\t\tthis.currentToken = token;\n\t\t\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tif (!OT.checkSystemRequirements()) {\n\t\t\t\tthis.callStateSubject.next(CallState.ERROR);\n\t\t\t\treject(new Error(\"Browser not compatible with TokBox\"));\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthis.session = OT.initSession(this.config.tokBoxApiKey, sessionId);\n\n\t\t\t// Handle new streams (remote participants joining)\n\t\t\tthis.session.on(\"streamCreated\", (event) => {\n\t\t\t\tconst subscriber = this.session?.subscribe(\n\t\t\t\t\tevent.stream,\n\t\t\t\t\tsubscriberElement,\n\t\t\t\t\t{\n\t\t\t\t\t\tinsertMode: \"append\",\n\t\t\t\t\t\twidth: \"100%\",\n\t\t\t\t\t\theight: \"100%\",\n\t\t\t\t\t},\n\t\t\t\t\t(error) => {\n\t\t\t\t\t\tif (error) {\n\t\t\t\t\t\t\tconsole.error(\"Error subscribing to stream:\", error);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t\tif (subscriber) {\n\t\t\t\t\tthis.subscribers.push(subscriber);\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// Handle streams ending (remote participants leaving)\n\t\t\tthis.session.on(\"streamDestroyed\", (event) => {\n\t\t\t\tthis.subscribers = this.subscribers.filter(\n\t\t\t\t\t(sub) => sub.stream?.streamId !== event.stream.streamId\n\t\t\t\t);\n\t\t\t});\n\n\t\t\t// Handle session disconnection\n\t\t\tthis.session.on(\"sessionDisconnected\", () => {\n\t\t\t\tthis.callStateSubject.next(CallState.DISCONNECTED);\n\t\t\t});\n\n\t\t\t// Connect to session\n\t\t\tthis.session.connect(token, (error) => {\n\t\t\t\tif (error) {\n\t\t\t\t\tconsole.error(\"Error connecting to session:\", error);\n\t\t\t\t\tthis.callStateSubject.next(CallState.ERROR);\n\t\t\t\t\treject(error);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Initialize publisher (local video)\n\t\t\t\tthis.publisher = OT.initPublisher(\n\t\t\t\t\tpublisherElement,\n\t\t\t\t\t{\n\t\t\t\t\t\tinsertMode: \"append\",\n\t\t\t\t\t\twidth: \"100%\",\n\t\t\t\t\t\theight: \"100%\",\n\t\t\t\t\t},\n\t\t\t\t\t(err) => {\n\t\t\t\t\t\tif (err) {\n\t\t\t\t\t\t\tconsole.error(\"Error initializing publisher:\", err);\n\t\t\t\t\t\t\tthis.callStateSubject.next(CallState.ERROR);\n\t\t\t\t\t\t\treject(err);\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Publish to session\n\t\t\t\t\t\tthis.session?.publish(this.publisher, (pubErr) => {\n\t\t\t\t\t\t\tif (pubErr) {\n\t\t\t\t\t\t\t\tconsole.error(\"Error publishing stream:\", pubErr);\n\t\t\t\t\t\t\t\tthis.callStateSubject.next(CallState.ERROR);\n\t\t\t\t\t\t\t\treject(pubErr);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.callStateSubject.next(CallState.CONNECTED);\n\t\t\t\t\t\t\t\tresolve();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t});\n\t\t});\n\t}\n\n\t// Video Element Movement Methods\n\tpublic movePublisherTo(newContainerId: string): void {\n\t\tif (!this.publisher) return;\n\t\t\n\t\tconst publisherElement = this.publisher.element;\n\t\tconst newContainer = document.getElementById(newContainerId);\n\t\t\n\t\tif (publisherElement && newContainer) {\n\t\t\tnewContainer.appendChild(publisherElement);\n\t\t}\n\t}\n\n\tpublic moveSubscribersTo(newContainerId: string): void {\n\t\tconst newContainer = document.getElementById(newContainerId);\n\t\tif (!newContainer) return;\n\t\t\n\t\tthis.subscribers.forEach((subscriber) => {\n\t\t\tconst subscriberElement = subscriber.element;\n\t\t\tif (subscriberElement) {\n\t\t\t\tnewContainer.appendChild(subscriberElement);\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Moves the main video (subscriber if available, otherwise publisher) to a container.\n\t * Used for PiP mode to show only one video.\n\t */\n\tpublic moveMainVideoTo(newContainerId: string): void {\n\t\tconst newContainer = document.getElementById(newContainerId);\n\t\tif (!newContainer) return;\n\n\t\t// Prefer remote video (subscriber) as main\n\t\tif (this.subscribers.length > 0 && this.subscribers[0].element) {\n\t\t\tnewContainer.appendChild(this.subscribers[0].element);\n\t\t\treturn;\n\t\t}\n\n\t\t// Fall back to local video (publisher)\n\t\tif (this.publisher?.element) {\n\t\t\tnewContainer.appendChild(this.publisher.element);\n\t\t}\n\t}\n\n\t/**\n\t * Moves videos back to fullscreen containers\n\t */\n\tpublic moveVideosToFullscreen(): void {\n\t\tthis.moveSubscribersTo('subscriber-container');\n\t\tthis.movePublisherTo('publisher-container');\n\t}\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tas.service.js","sourceRoot":"","sources":["../../../../../projects/tas-uell-sdk/src/lib/services/tas.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport * as OT from '@opentok/client';\nimport {\n  GenerateTokenResponse,\n  StartSessionRequest,\n  FinishSessionResponse,\n  ProxyVideoStatusRequest,\n  ProxyVideoStatusResponse,\n  ProxyVideoFinishRequest,\n  ProxyVideoUserModifyRequest,\n  UserCallAction,\n  RoomUserStatus,\n  TasCurrentUser,\n  TasBusinessRole,\n  TasUserRole,\n  CallState,\n  ViewMode,\n  WaitingRoomUser,\n  TasAppointment,\n  GetAppointmentsRequest,\n} from '../interfaces/tas.interfaces';\nimport {\n  TAS_CONFIG,\n  TAS_HTTP_CLIENT,\n  TasConfig,\n  TasHttpClient,\n} from '../config/tas.config';\n\n// Re-export enums for backward compatibility\nexport { CallState, ViewMode, TasBusinessRole, UserCallAction, RoomUserStatus };\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TasService {\n  private session: OT.Session | null = null;\n  private publisher: OT.Publisher | null = null;\n  private subscribers: OT.Subscriber[] = [];\n\n  private callStateSubject = new BehaviorSubject<CallState>(CallState.IDLE);\n  public callState$ = this.callStateSubject.asObservable();\n\n  private viewModeSubject = new BehaviorSubject<ViewMode>(ViewMode.FULLSCREEN);\n  public viewMode$ = this.viewModeSubject.asObservable();\n\n  private isMutedSubject = new BehaviorSubject<boolean>(false);\n  public isMuted$ = this.isMutedSubject.asObservable();\n\n  // Session info for PiP mode restoration\n  private currentSessionId: string | null = null;\n  private currentToken: string | null = null;\n  private readonly STORAGE_KEY = 'tas_session_state';\n  private readonly DISCONNECTED_FLAG_KEY = 'tas_session_disconnected';\n  private isFinishingSession: boolean = false;\n\n  // Proxy-video circuit state\n  private proxyVideoSessionId: string | null = null;\n  private proxyVideoToken: string | null = null;\n  private currentBusinessRole: TasBusinessRole = TasBusinessRole.USER;\n\n  // Waiting room and status polling\n  private waitingRoomUsersSubject = new BehaviorSubject<WaitingRoomUser[]>([]);\n  public waitingRoomUsers$ = this.waitingRoomUsersSubject.asObservable();\n\n  private ownerHasJoinedSubject = new BehaviorSubject<boolean>(false);\n  public ownerHasJoined$ = this.ownerHasJoinedSubject.asObservable();\n\n  // Observable that emits true when owner was present but then left\n  private ownerHasLeftSubject = new BehaviorSubject<boolean>(false);\n  public ownerHasLeft$ = this.ownerHasLeftSubject.asObservable();\n\n  private joinableSubject = new BehaviorSubject<boolean>(false);\n  public joinable$ = this.joinableSubject.asObservable();\n\n  // Observable for when backend requests geolocation activation\n  private activateGeoSubject = new BehaviorSubject<boolean>(false);\n  public activateGeo$ = this.activateGeoSubject.asObservable();\n\n  // Observable for when geo request is active (owner waiting for user response)\n  private geoRequestActiveSubject = new BehaviorSubject<boolean>(false);\n  public geoRequestActive$ = this.geoRequestActiveSubject.asObservable();\n\n  // Observable for when all geo has been granted\n  private allGeoGrantedSubject = new BehaviorSubject<boolean>(false);\n  public allGeoGranted$ = this.allGeoGrantedSubject.asObservable();\n\n  private statusPollingInterval: ReturnType<typeof setInterval> | null = null;\n  private readonly DEFAULT_POLL_INTERVAL_MS = 30000; // Default 30s\n  private wasOwnerPresent = false;\n\n  // Current call context\n  private currentAppointmentId: number | null = null;\n  private currentVideoCallId: number | null = null;\n  private currentTenant: string | null = null;\n\n  constructor(\n    @Inject(TAS_HTTP_CLIENT) private httpClient: TasHttpClient,\n    @Inject(TAS_CONFIG) private config: TasConfig\n  ) {}\n\n  // ... (Getters and other methods remain unchanged)\n\n  /**\n   * Start automatic status polling for the current session.\n   * Status is polled every intervalMs (default 30s).\n   */\n  public startStatusPolling(\n    params: ProxyVideoStatusRequest, \n    intervalMs: number = this.DEFAULT_POLL_INTERVAL_MS\n  ): void {\n    this.stopStatusPolling(); // Clear any existing polling\n\n    // Store context for polling\n    if (params.sessionId) {\n      this.currentSessionId = params.sessionId;\n    }\n    if (params.appointmentId) {\n      this.currentAppointmentId = params.appointmentId;\n    }\n    if (params.tenant) {\n      this.currentTenant = params.tenant;\n    }\n\n    console.log(`[TAS DEBUG] Starting status polling with interval ${intervalMs}ms`);\n\n    // Initial status fetch\n    this.fetchAndProcessStatus(params);\n\n    // Set up periodic polling\n    this.statusPollingInterval = setInterval(() => {\n      this.fetchAndProcessStatus(params);\n    }, intervalMs);\n  }\n\n  /**\n   * Stop automatic status polling.\n   */\n  public stopStatusPolling(): void {\n    if (this.statusPollingInterval) {\n      clearInterval(this.statusPollingInterval);\n      this.statusPollingInterval = null;\n    }\n    // Do NOT reset waiting room state here, as other components might observe it\n  }\n\n  /**\n   * Reset polling state (waiting room, owner status, etc)\n   * Call this when completely exiting the flow\n   */\n  public resetPollingState(): void {\n    this.stopStatusPolling();\n    this.waitingRoomUsersSubject.next([]);\n    this.ownerHasJoinedSubject.next(false);\n    this.ownerHasLeftSubject.next(false);\n    this.joinableSubject.next(false);\n    this.wasOwnerPresent = false;\n  }\n\n  // Getters\n  public get currentSession(): OT.Session | null {\n    return this.session;\n  }\n\n  public get currentPublisher(): OT.Publisher | null {\n    return this.publisher;\n  }\n\n  public get currentSubscribers(): OT.Subscriber[] {\n    return this.subscribers;\n  }\n\n  public get sessionId(): string | null {\n    return this.currentSessionId;\n  }\n\n  public get token(): string | null {\n    return this.currentToken;\n  }\n\n  public get proxySessionId(): string | null {\n    return this.proxyVideoSessionId;\n  }\n\n  public get proxyToken(): string | null {\n    return this.proxyVideoToken;\n  }\n\n  public get businessRole(): TasBusinessRole {\n    return this.currentBusinessRole;\n  }\n\n  public get isMuted(): boolean {\n    return this.isMutedSubject.getValue();\n  }\n\n  // View Mode Methods\n  public setViewMode(mode: ViewMode): void {\n    this.viewModeSubject.next(mode);\n    if (this.currentSessionId && this.currentToken) {\n      this.saveSessionState(\n        this.currentSessionId,\n        this.currentToken,\n        mode,\n        this.currentBusinessRole\n      );\n    }\n  }\n\n  public enterPipMode(): void {\n    this.viewModeSubject.next(ViewMode.PIP);\n    if (this.currentSessionId && this.currentToken) {\n      this.saveSessionState(\n        this.currentSessionId,\n        this.currentToken,\n        ViewMode.PIP,\n        this.currentBusinessRole\n      );\n    }\n  }\n\n  public exitPipMode(): void {\n    this.viewModeSubject.next(ViewMode.FULLSCREEN);\n    if (this.currentSessionId && this.currentToken) {\n      this.saveSessionState(\n        this.currentSessionId,\n        this.currentToken,\n        ViewMode.FULLSCREEN,\n        this.currentBusinessRole\n      );\n    }\n  }\n\n  public isPipMode(): boolean {\n    return this.viewModeSubject.getValue() === ViewMode.PIP;\n  }\n\n  // Audio Control\n  public toggleMute(): void {\n    if (this.publisher) {\n      const newMuteState = !this.isMutedSubject.getValue();\n      const shouldEnableAudio = !newMuteState;\n\n      // Use OpenTok's publishAudio\n      this.publisher.publishAudio(shouldEnableAudio);\n\n      // Also directly control the MediaStreamTrack as backup\n      const audioTrack = this.publisher.getAudioSource?.();\n      if (audioTrack) {\n        audioTrack.enabled = shouldEnableAudio;\n      }\n\n      this.isMutedSubject.next(newMuteState);\n    }\n  }\n\n  public setMute(muted: boolean): void {\n    if (this.publisher) {\n      this.publisher.publishAudio(!muted);\n      this.isMutedSubject.next(muted);\n    }\n  }\n\n  // Session Management\n  public disconnectSession(clearStorage: boolean = true): void {\n    console.log(\n      '[TAS DEBUG] TasService.disconnectSession called. clearStorage:',\n      clearStorage\n    );\n\n    // Call finishSession before disconnecting if we have a sessionId\n    const sessionIdToFinish = this.currentSessionId;\n\n    // Clear storage FIRST to prevent any race conditions where state might be saved after disconnect\n    if (clearStorage) {\n      this.clearSessionState();\n      // Set a flag to indicate this session was intentionally disconnected\n      // This prevents reconnection on page reload\n      sessionStorage.setItem(this.DISCONNECTED_FLAG_KEY, 'true');\n    }\n\n    if (this.session) {\n      this.session.disconnect();\n      this.session = null;\n    }\n    this.publisher = null;\n    this.subscribers = [];\n    this.currentSessionId = null;\n    this.currentToken = null;\n    this.proxyVideoSessionId = null;\n    this.proxyVideoToken = null;\n    this.isMutedSubject.next(false); // Reset mute state\n    this.viewModeSubject.next(ViewMode.FULLSCREEN);\n    this.callStateSubject.next(CallState.DISCONNECTED);\n\n    // Call proxy finish after disconnecting (only if not already finishing)\n    if (sessionIdToFinish && !this.isFinishingSession) {\n      this.isFinishingSession = true;\n      this.finishProxyVideoSession({\n        sessionId: sessionIdToFinish,\n        businessRole: this.currentBusinessRole,\n      }).subscribe({\n        next: (response) => {\n          console.log('[TAS DEBUG] Session finished successfully:', response);\n          this.isFinishingSession = false;\n        },\n        error: (error) => {\n          console.error('[TAS DEBUG] Error finishing session:', error);\n          this.isFinishingSession = false;\n        },\n      });\n    }\n  }\n\n  public isCallActive(): boolean {\n    return this.callStateSubject.getValue() === CallState.CONNECTED;\n  }\n\n  // State Persistence\n  private saveSessionState(\n    sessionId: string,\n    token: string,\n    viewMode: ViewMode,\n    businessRole: TasBusinessRole = TasBusinessRole.USER\n  ): void {\n    const state = {\n      sessionId,\n      token,\n      viewMode,\n      businessRole,\n    };\n    sessionStorage.setItem(this.STORAGE_KEY, JSON.stringify(state));\n  }\n\n  private clearSessionState(): void {\n    sessionStorage.removeItem(this.STORAGE_KEY);\n    // Also clear the disconnected flag when clearing state\n    sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);\n  }\n\n  public canRestoreSession(): boolean {\n    return !!sessionStorage.getItem(this.STORAGE_KEY);\n  }\n\n  public restoreSession(containerId: string): void {\n    const savedState = sessionStorage.getItem(this.STORAGE_KEY);\n    if (!savedState) return;\n\n    // Check if this session was intentionally disconnected\n    // If so, don't restore it on page reload\n    const wasDisconnected = sessionStorage.getItem(this.DISCONNECTED_FLAG_KEY);\n    if (wasDisconnected === 'true') {\n      console.log('[TAS DEBUG] Session was intentionally disconnected, skipping restore');\n      this.clearSessionState();\n      sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);\n      return;\n    }\n\n    // Don't restore if we're already disconnected or if there's no active session\n    // This prevents restoring sessions that were properly disconnected\n    if (this.callStateSubject.getValue() === CallState.DISCONNECTED) {\n      console.log('[TAS DEBUG] Call state is DISCONNECTED, skipping restore');\n      this.clearSessionState();\n      return;\n    }\n\n    try {\n      const state = JSON.parse(savedState);\n      if (state.sessionId && state.token) {\n        console.log('[TAS DEBUG] Restoring session from storage');\n        // Force PiP mode for restoration to ensure UI consistency\n        this.viewModeSubject.next(ViewMode.PIP);\n\n        if (state.businessRole) {\n          this.currentBusinessRole = state.businessRole;\n        }\n\n        this.connectSession(\n          state.sessionId,\n          state.token,\n          containerId, // Use the same container for both since we are in PiP\n          containerId,\n          this.currentBusinessRole\n        )\n          .then(() => {\n            console.log('[TAS DEBUG] Session restored successfully');\n            // Clear the disconnected flag if restoration succeeds\n            sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);\n          })\n          .catch((err) => {\n            console.error('[TAS DEBUG] Failed to restore session:', err);\n            this.clearSessionState(); // Clear bad state\n          });\n      }\n    } catch (e) {\n      console.error('[TAS DEBUG] Error parsing saved session state', e);\n      this.clearSessionState();\n    }\n  }\n\n  // API Methods\n  /**\n   * PROXY circuit token: /v2/proxy/video/start\n   */\n  public startProxyVideoSession(\n    payload: StartSessionRequest\n  ): Observable<GenerateTokenResponse> {\n    return this.httpClient\n      .post<GenerateTokenResponse>('v2/proxy/video/start', {\n        body: payload,\n        headers: {},\n      })\n      .pipe(\n        map((response: any) => response as GenerateTokenResponse),\n        catchError((error) => {\n          console.error('TAS Service: startProxyVideoSession failed', error);\n          throw error;\n        })\n      );\n  }\n\n  /**\n   * PROXY circuit status: /v2/proxy/video/status\n   */\n  public getProxyVideoStatus(\n    payload: ProxyVideoStatusRequest\n  ): Observable<ProxyVideoStatusResponse> {\n    return this.httpClient\n      .post<ProxyVideoStatusResponse>('v2/proxy/video/status', {\n        body: payload,\n        headers: {},\n      })\n      .pipe(\n        map((response: any) => response as ProxyVideoStatusResponse),\n        catchError((error) => {\n          console.error('TAS Service: getProxyVideoStatus failed', error);\n          throw error;\n        })\n      );\n  }\n\n  /**\n   * PROXY circuit user modification: /v2/proxy/video/user/modify\n   */\n  public modifyProxyVideoUser(payload: ProxyVideoUserModifyRequest): Observable<any> {\n    return this.httpClient\n      .patch<any>('v2/proxy/video/user/modify', {\n        body: payload,\n        headers: {},\n      })\n      .pipe(\n        catchError((error) => {\n          console.error('TAS Service: modifyProxyVideoUser failed', error);\n          throw error;\n        })\n      );\n  }\n\n  public finishProxyVideoSession(payload: ProxyVideoFinishRequest) {\n    return this.httpClient\n      .post<FinishSessionResponse>('v2/proxy/video/finish', {\n        body: payload,\n        headers: {},\n      })\n      .pipe(\n        map((response: any) => response as FinishSessionResponse),\n        catchError((error) => {\n          console.error('TAS Service: finishProxyVideoSession failed', error);\n          throw error;\n        })\n      );\n  }\n\n  /**\n   * Get user appointments within a date range.\n   * @param params Date range for querying appointments\n   * @returns Observable of appointment array\n   */\n  public getAppointments(params: GetAppointmentsRequest): Observable<TasAppointment[]> {\n    return this.httpClient\n      .get<TasAppointment[]>(\n        `v2/proxy/appointment/agendas/user/appointments?fromDate=${params.fromDate}&toDate=${params.toDate}`,\n        { headers: {} }\n      )\n      .pipe(\n        catchError((error) => {\n          console.error('TAS Service: getAppointments failed', error);\n          throw error;\n        })\n      );\n  }\n\n  /**\n   * Start automatic status polling for the current session.\n   * Status is polled every STATUS_POLL_INTERVAL_MS milliseconds.\n   */\n\n\n  /**\n   * Stop automatic status polling.\n   */\n\n\n  /**\n   * Fetch status and process the response.\n   */\n  private fetchAndProcessStatus(params: ProxyVideoStatusRequest): void {\n    this.getProxyVideoStatus(params).subscribe({\n      next: (response) => {\n        this.processStatusResponse(response);\n      },\n      error: (err) => {\n        console.error('[TAS DEBUG] Status polling error:', err);\n      },\n    });\n  }\n\n  /**\n   * Process status response to update waiting room users and owner join status.\n   */\n  private processStatusResponse(response: ProxyVideoStatusResponse): void {\n    const content = response.content;\n\n    // Update videoCallId if available\n    if (content.videoCallId) {\n      this.currentVideoCallId = content.videoCallId;\n    }\n\n    // Update sessionId if available\n    if (content.sessionId) {\n      this.currentSessionId = content.sessionId;\n      this.proxyVideoSessionId = content.sessionId;\n    }\n\n    // Update joinable status\n    this.joinableSubject.next(content.joinable);\n\n    // Update activateGeo status\n    if (content.activateGeo !== undefined) {\n      console.log('[TAS DEBUG] activateGeo received:', content.activateGeo);\n      this.activateGeoSubject.next(content.activateGeo);\n    }\n\n    // Update geoRequestActive status (owner waiting for user geo response)\n    if (content.geoRequestActive !== undefined) {\n      console.log('[TAS DEBUG] geoRequestActive received:', content.geoRequestActive);\n      this.geoRequestActiveSubject.next(content.geoRequestActive);\n    }\n\n    // Update allGeoGranted status (all users responded with geo)\n    if (content.allGeoGranted !== undefined) {\n      console.log('[TAS DEBUG] allGeoGranted received:', content.allGeoGranted);\n      this.allGeoGrantedSubject.next(content.allGeoGranted);\n    }\n\n    // Check if owner has joined\n    const ownerJoined = this.checkIfOwnerJoined(content.users);\n    this.ownerHasJoinedSubject.next(ownerJoined);\n\n    // Detect if owner left: was present, now not present\n    if (this.wasOwnerPresent && !ownerJoined) {\n      console.log('[TAS DEBUG] Owner has left the session');\n      this.ownerHasLeftSubject.next(true);\n    }\n\n    if (ownerJoined) {\n      this.wasOwnerPresent = true;\n    }\n\n    // Extract waiting room users (status === WAITING)\n    const waitingUsers: WaitingRoomUser[] = content.users\n      .filter((u) => (u.status as string) === 'WAITING')\n      .map((u) => ({\n        userId: u.userId,\n        name: `User ${u.userId}`, // TODO: Fetch actual user names from a user service\n        status: RoomUserStatus.WAITING,\n      }));\n\n    this.waitingRoomUsersSubject.next(waitingUsers);\n  }\n\n  /**\n   * Check if at least one OWNER has joined the call.\n   */\n  private checkIfOwnerJoined(\n    users: { userId: number; rol: string; status: string }[]\n  ): boolean {\n    return users.some(\n      (u) => u.rol === TasUserRole.OWNER && u.status === 'JOINED'\n    );\n  }\n\n  /**\n   * Admit a user from the waiting room by changing their status.\n   */\n  public admitUserFromWaitingRoom(\n    userId: number,\n    videoCallId: number\n  ): Observable<any> {\n    return this.modifyProxyVideoUser({\n      userId,\n      videoCallId,\n      action: UserCallAction.WAITING_ROOM_LEAVE,\n    });\n  }\n\n  // Getters for current call context\n  public get appointmentId(): number | null {\n    return this.currentAppointmentId;\n  }\n\n  public get videoCallId(): number | null {\n    return this.currentVideoCallId;\n  }\n\n  /**\n   * Connects to a TokBox video session\n   */\n  public connectSession(\n    sessionId: string,\n    token: string,\n    publisherElement: string,\n    subscriberElement: string,\n    businessRole: TasBusinessRole = TasBusinessRole.USER\n  ): Promise<void> {\n    this.callStateSubject.next(CallState.CONNECTING);\n    this.currentSessionId = sessionId;\n    this.currentToken = token;\n    this.currentBusinessRole = businessRole;\n    this.isFinishingSession = false; // Reset flag for new session\n\n    // Save initial state (defaulting to current view mode)\n    this.saveSessionState(\n      sessionId,\n      token,\n      this.viewModeSubject.getValue(),\n      businessRole\n    );\n    // Clear the disconnected flag when starting a new connection\n    sessionStorage.removeItem(this.DISCONNECTED_FLAG_KEY);\n\n    return new Promise((resolve, reject) => {\n      if (!OT.checkSystemRequirements()) {\n        this.callStateSubject.next(CallState.ERROR);\n        reject(new Error('Browser not compatible with TokBox'));\n        return;\n      }\n\n      this.session = OT.initSession(this.config.tokBoxApiKey, sessionId);\n\n      // Handle new streams (remote participants joining)\n      this.session.on('streamCreated', (event) => {\n        const subscriber = this.session?.subscribe(\n          event.stream,\n          subscriberElement,\n          {\n            insertMode: 'append',\n            width: '100%',\n            height: '100%',\n          },\n          (error) => {\n            if (error) {\n              console.error('Error subscribing to stream:', error);\n            }\n          }\n        );\n        if (subscriber) {\n          this.subscribers.push(subscriber);\n        }\n      });\n\n      // Handle streams ending (remote participants leaving)\n      this.session.on('streamDestroyed', (event) => {\n        this.subscribers = this.subscribers.filter(\n          (sub) => sub.stream?.streamId !== event.stream.streamId\n        );\n      });\n\n      // Handle session disconnection\n      this.session.on('sessionDisconnected', () => {\n        this.callStateSubject.next(CallState.DISCONNECTED);\n\n        // Call finishSession when session is disconnected (e.g., by server)\n        // Only call if not already finishing (prevents duplicate calls)\n        const sessionIdToFinish = this.currentSessionId;\n        if (sessionIdToFinish && !this.isFinishingSession) {\n          this.isFinishingSession = true;\n          this.finishProxyVideoSession({\n            sessionId: sessionIdToFinish,\n            businessRole: this.currentBusinessRole,\n          }).subscribe({\n            next: (response) => {\n              console.log('[TAS DEBUG] Session finished on disconnect event:', response);\n              this.isFinishingSession = false;\n            },\n            error: (error) => {\n              console.error('[TAS DEBUG] Error finishing session on disconnect:', error);\n              this.isFinishingSession = false;\n            },\n          });\n        }\n      });\n\n      // Connect to session\n      this.session.connect(token, (error) => {\n        if (error) {\n          console.error('Error connecting to session:', error);\n          this.callStateSubject.next(CallState.ERROR);\n          reject(error);\n          return;\n        }\n\n        // Initialize publisher (local video)\n        this.publisher = OT.initPublisher(\n          publisherElement,\n          {\n            insertMode: 'append',\n            width: '100%',\n            height: '100%',\n          },\n          (err) => {\n            if (err) {\n              console.error('Error initializing publisher:', err);\n              this.callStateSubject.next(CallState.ERROR);\n              reject(err);\n              return;\n            }\n\n            // Publish to session\n            this.session?.publish(this.publisher, (pubErr) => {\n              if (pubErr) {\n                console.error('Error publishing stream:', pubErr);\n                this.callStateSubject.next(CallState.ERROR);\n                reject(pubErr);\n              } else {\n                this.callStateSubject.next(CallState.CONNECTED);\n                resolve();\n              }\n            });\n          }\n        );\n      });\n    });\n  }\n\n  // Video Element Movement Methods\n  public movePublisherTo(newContainerId: string): void {\n    if (!this.publisher) return;\n\n    const publisherElement = this.publisher.element;\n    const newContainer = document.getElementById(newContainerId);\n\n    if (publisherElement && newContainer) {\n      newContainer.appendChild(publisherElement);\n    }\n  }\n\n  public moveSubscribersTo(newContainerId: string): void {\n    const newContainer = document.getElementById(newContainerId);\n    if (!newContainer) return;\n\n    this.subscribers.forEach((subscriber) => {\n      const subscriberElement = subscriber.element;\n      if (subscriberElement) {\n        newContainer.appendChild(subscriberElement);\n      }\n    });\n  }\n\n  /**\n   * Moves the main video (subscriber if available, otherwise publisher) to a container.\n   * Used for PiP mode to show only one video.\n   */\n  public moveMainVideoTo(newContainerId: string): void {\n    const newContainer = document.getElementById(newContainerId);\n    if (!newContainer) return;\n\n    // Prefer remote video (subscriber) as main\n    if (this.subscribers.length > 0 && this.subscribers[0].element) {\n      newContainer.appendChild(this.subscribers[0].element);\n      return;\n    }\n\n    // Fall back to local video (publisher)\n    if (this.publisher?.element) {\n      newContainer.appendChild(this.publisher.element);\n    }\n  }\n\n  /**\n   * Moves videos back to fullscreen containers\n   */\n  public moveVideosToFullscreen(): void {\n    this.moveSubscribersTo('subscriber-container');\n    this.movePublisherTo('publisher-container');\n  }\n}\n"]}