cloud-ide-layout 0.0.1 → 1.0.1

package/esm2022/lib/layout/shared/shared.service.mjs

@@ -1,26 +1,502 @@
-import { Injectable } from '@angular/core';
+import { Injectable, inject, signal, computed } from '@angular/core';
 import { cidePath, designConfigRoutesUrl, hostManagerRoutesUrl } from 'cloud-ide-lms-model';
+import { HttpClient } from '@angular/common/http';
+import { of, throwError } from 'rxjs';
+import { tap, catchError, shareReplay, filter, take } from 'rxjs/operators';
+import { Router, NavigationEnd } from '@angular/router';
+import { Title } from '@angular/platform-browser';
+import { CideElementsService } from 'cloud-ide-element';
+import { CideLytSidebarService } from '../sidebar/sidebar.service';
+import { CideLytHeaderService } from '../header/header.service';
+import { CideLytFooterService } from '../footer/footer.service';
+import { CideLytConsoleService } from '../console/console.service';
+import { CideLytSidedrawerService } from '../sidedrawer/sidedrawer.service';
+import { AppStateHelperService } from '../../services/app-state/app-state-helper.service';
 import * as i0 from "@angular/core";
-import * as i1 from "cloud-ide-element";
-import * as i2 from "@angular/common/http";
-import * as i3 from "@angular/platform-browser";
 export class CideLytSharedService {
-    constructor(elementService, http, titleService) {
-        this.elementService = elementService;
-        this.http = http;
-        this.titleService = titleService;
+    constructor() {
+        // Clean up expired cache entries every minute
+        // setInterval(() => this.cleanExpiredCache(), 60000);
+        // Enhanced reactive cache with signals
+        this.pageDataCacheSignal = signal({});
+        this.loadingStateSignal = signal({});
+        // Public readonly access to cache
+        this.pageDataCache = this.pageDataCacheSignal.asReadonly();
+        this.loadingStates = this.loadingStateSignal.asReadonly();
+        // Computed signal for cache status
+        this.cacheInfo = computed(() => {
+            const cache = this.pageDataCacheSignal();
+            return {
+                totalCached: Object.keys(cache).length,
+                validCached: Object.values(cache).filter(item => this.isCacheValid(item)).length,
+                expiredCached: Object.values(cache).filter(item => !this.isCacheValid(item)).length
+            };
+        });
+        // In-flight requests to prevent duplicate API calls
+        this.inflightRequests = {};
+        // Default cache TTL (5 minutes)
+        this.DEFAULT_CACHE_TTL = 5 * 60 * 1000;
+        // Modern Angular v20 dependency injection pattern
+        this.elementService = inject(CideElementsService);
+        this.http = inject(HttpClient);
+        this.titleService = inject(Title);
+        this.sidebarService = inject(CideLytSidebarService);
+        this.headerService = inject(CideLytHeaderService);
+        this.footerService = inject(CideLytFooterService);
+        this.consoleService = inject(CideLytConsoleService);
+        this.sidedrawerService = inject(CideLytSidedrawerService);
+        this.router = inject(Router);
+        // Import AppStateHelperService for sidebar sync
+        this.appState = inject(AppStateHelperService);
+        // Listen to route changes - moved from request service
+        this.routeSubscription = this.router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe(() => {
+            // Cancel any ongoing page data fetching
+            this.pageDataSubscription?.unsubscribe();
+            this.handleRouteChange();
+        });
     }
-    loadPageData(body) {
-        return this.http.post(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.getPageData]), body);
+    /**
+     * Register tab management callback from request service
+     * This allows shared service to call request service without circular dependency
+     */
+    registerTabManagement(callback) {
+        this.tabManagementCallback = callback;
+        console.log('✅ Tab management callback registered');
     }
-    setPageData(page_data_response) {
+    /**
+     * Register request visibility callback from request service
+     * This allows shared service to control request wrapper visibility
+     */
+    registerRequestVisibility(callback) {
+        this.requestVisibilityCallback = callback;
+        console.log('✅ Request visibility callback registered');
+    }
+    /**
+     * Enhanced loadPageData with caching and deduplication
+     * @param body - Request payload
+     * @param forceRefresh - Force API call even if cached data exists
+     * @param customTTL - Custom cache TTL in milliseconds
+     */
+    loadPageData(body, forceRefresh = false, customTTL = this.DEFAULT_CACHE_TTL) {
+        const pageCode = body.sypg_page_code?.toString() || '';
+        if (!pageCode) {
+            return throwError(() => new Error('Page code is required'));
+        }
+        // Check if we have valid cached data and not forcing refresh
+        if (!forceRefresh && this.hasValidCache(pageCode)) {
+            console.log(`🔄 CACHE HIT: Using cached data for page code: ${pageCode}`);
+            const cachedData = this.pageDataCacheSignal()[pageCode];
+            return of(cachedData.response);
+        }
+        // Check if there's already an in-flight request for this page code
+        if (this.inflightRequests[pageCode]) {
+            console.log(`🔄 INFLIGHT REQUEST: Returning existing request for page code: ${pageCode}`);
+            return this.inflightRequests[pageCode];
+        }
+        // Set loading state
+        this.setLoadingState(pageCode, true);
+        console.log(`🌐 API CALL: Loading fresh data for page code: ${pageCode}`);
+        // Create new API request
+        const request$ = this.http.post(cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.getPageData]), body);
+        // Cache the observable to prevent duplicate requests
+        this.inflightRequests[pageCode] = request$.pipe(tap(response => {
+            console.log(`✅ API SUCCESS: Caching data for page code: ${pageCode}`);
+            this.cachePageData(pageCode, body, response, customTTL);
+            this.setLoadingState(pageCode, false);
+        }), catchError(error => {
+            console.error(`❌ API ERROR: Failed to load data for page code: ${pageCode}`, error);
+            this.setLoadingState(pageCode, false);
+            return throwError(() => error);
+        }), shareReplay(1) // Share the result with multiple subscribers
+        );
+        // Clean up inflight request after completion
+        this.inflightRequests[pageCode].subscribe({
+            complete: () => {
+                delete this.inflightRequests[pageCode];
+            },
+            error: () => {
+                delete this.inflightRequests[pageCode];
+            }
+        });
+        return this.inflightRequests[pageCode];
+    }
+    /**
+     * Consolidated method to load and process page data
+     * This replaces the separate calls in request service and shared wrapper
+     */
+    loadAndProcessPageData(body, options = {}) {
+        const { forceRefresh = false, customTTL = this.DEFAULT_CACHE_TTL, setTitle = true, setSidebarContext = true, updateLayout = true } = options;
+        return this.loadPageData(body, forceRefresh, customTTL).pipe(tap(response => {
+            if (response) {
+                console.log('🔍 SHARED SERVICE: loadAndProcessPageData', response);
+                // Process the response
+                if (updateLayout) {
+                    this.setPageData(response, body);
+                }
+                // Set page title
+                if (setTitle && response.data?.page?.sypg_title) {
+                    this.titleService.setTitle(response.data.page.sypg_title);
+                }
+                // Set sidebar context
+                if (setSidebarContext) {
+                    // This will be handled by the component that needs the context
+                    // as it's specific to the sidedrawer service
+                }
+            }
+        }));
+    }
+    /**
+     * Get cached page data without making API call
+     */
+    getCachedPageData(pageCode) {
+        const cached = this.pageDataCacheSignal()[pageCode];
+        return this.isCacheValid(cached) ? cached.response : null;
+    }
+    /**
+     * Check if loading for a specific page code
+     */
+    isLoading(pageCode) {
+        return this.loadingStates()[pageCode] || false;
+    }
+    /**
+     * Invalidate cache for specific page code
+     */
+    invalidateCache(pageCode) {
+        const cache = { ...this.pageDataCacheSignal() };
+        delete cache[pageCode];
+        this.pageDataCacheSignal.set(cache);
+        console.log(`🗑️ CACHE INVALIDATED: Removed cache for page code: ${pageCode}`);
+    }
+    /**
+     * Clear all cached data
+     */
+    clearAllCache() {
+        this.pageDataCacheSignal.set({});
+        this.loadingStateSignal.set({});
+        console.log('🗑️ CACHE CLEARED: All cached data removed');
+    }
+    /**
+     * Preload page data for better performance
+     */
+    preloadPageData(pageCodes) {
+        pageCodes.forEach(pageCode => {
+            if (!this.hasValidCache(pageCode) && !this.isLoading(pageCode)) {
+                this.loadPageData({ sypg_page_code: pageCode }).subscribe({
+                    next: () => console.log(`🚀 PRELOADED: Page data for ${pageCode}`),
+                    error: (err) => console.warn(`⚠️ PRELOAD FAILED: Could not preload ${pageCode}`, err)
+                });
+            }
+        });
+    }
+    // Private helper methods
+    hasValidCache(pageCode) {
+        const cached = this.pageDataCacheSignal()[pageCode];
+        return cached && this.isCacheValid(cached);
+    }
+    isCacheValid(cached) {
+        if (!cached)
+            return false;
+        return Date.now() - cached.timestamp < cached.ttl;
+    }
+    cachePageData(pageCode, request, response, ttl) {
+        const cache = { ...this.pageDataCacheSignal() };
+        cache[pageCode] = {
+            request,
+            response,
+            timestamp: Date.now(),
+            ttl
+        };
+        this.pageDataCacheSignal.set(cache);
+    }
+    setLoadingState(pageCode, loading) {
+        const loadingStates = { ...this.loadingStateSignal() };
+        if (loading) {
+            loadingStates[pageCode] = true;
+        }
+        else {
+            delete loadingStates[pageCode];
+        }
+        this.loadingStateSignal.set(loadingStates);
+    }
+    cleanExpiredCache() {
+        const cache = { ...this.pageDataCacheSignal() };
+        let cleaned = false;
+        Object.keys(cache).forEach(pageCode => {
+            if (!this.isCacheValid(cache[pageCode])) {
+                delete cache[pageCode];
+                cleaned = true;
+            }
+        });
+        if (cleaned) {
+            this.pageDataCacheSignal.set(cache);
+            console.log('🧹 CACHE CLEANUP: Removed expired cache entries');
+        }
+    }
+    setPageData(page_data_response, page_data_payload) {
+        // to set the controls data to the element service
+        console.log('🔍 SHARED SERVICE: setPageData', page_data_response, page_data_payload);
         if (page_data_response?.data?.controls) {
             // Set controls here
             this.elementService.cide_element_data = { ...this.elementService.cide_element_data, ...page_data_response?.data?.controls };
             this.elementService.is_cide_element_data_updated?.next(true);
         }
+        // while doing this we need to think about not to touch if this page is not pening in the popup or drower insted of main window
+        // Set the layout data
+        console.log('🔍 Layout data:', page_data_response);
+        if (page_data_response?.data?.theme?.sytm_layout) {
+            console.log('🔍 SIDEBAR DEBUG - Layout data:', page_data_response?.data?.theme?.sytm_layout, page_data_payload);
+            // check is sidebar is hiden or not (default is visible)
+            if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_sidebar) {
+                const sidebarStatus = page_data_response?.data?.theme?.sytm_layout?.sytm_layout_sidebar?.status;
+                console.log('🔍 SIDEBAR DEBUG - Sidebar status found:', sidebarStatus);
+                if (!sidebarStatus) {
+                    console.log('🚫 SIDEBAR DEBUG - Hiding sidebar because status is false');
+                    this.sidebarService.hideSidebar();
+                }
+                else {
+                    console.log('✅ SIDEBAR DEBUG - Showing sidebar because status is true');
+                    this.sidebarService.showSidebar();
+                }
+            }
+            else {
+                console.log('⚠️ SIDEBAR DEBUG - No sidebar config found, hiding sidebar');
+                this.sidebarService.hideSidebar();
+            }
+            // check header visible or not
+            console.log('🔍 HEADER DEBUG - Header config found:', page_data_response?.data?.theme?.sytm_layout?.sytm_layout_header);
+            if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_header) {
+                if (!page_data_response?.data?.theme?.sytm_layout?.sytm_layout_header?.status) {
+                    this.headerService.hideHeader();
+                }
+                else {
+                    this.headerService.showHeader();
+                }
+            }
+            else {
+                this.headerService.hideHeader();
+            }
+            // check footer visible or not 
+            if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_footer) {
+                if (!page_data_response?.data?.theme?.sytm_layout?.sytm_layout_footer?.status) {
+                    this.footerService.hideFooter();
+                }
+                else {
+                    this.footerService.showFooter();
+                }
+            }
+            else {
+                this.footerService.hideFooter();
+            }
+            // check console visible or not
+            if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_console) {
+                if (!page_data_response?.data?.theme?.sytm_layout?.sytm_layout_console?.status) {
+                    this.consoleService.hideConsole();
+                }
+                else {
+                    this.consoleService.showConsole();
+                }
+            }
+            else {
+                this.consoleService.hideConsole();
+            }
+            // check for the request status and log it for debugging
+            console.log('🔍 REQUEST DEBUG - Request config found:', page_data_response?.data?.theme?.sytm_layout?.sytm_layout_request);
+            if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_request) {
+                const requestStatus = page_data_response?.data?.theme?.sytm_layout?.sytm_layout_request?.status;
+                console.log('🔍 REQUEST DEBUG - Request status:', requestStatus, 'Type:', typeof requestStatus);
+                // The request status controls whether this page should support tabs
+                // This is used by the request service to determine if tabs should be created
+                if (requestStatus === true) {
+                    console.log('✅ REQUEST DEBUG - Request is enabled for tabbing');
+                    // Show request wrapper when request is enabled
+                    if (this.requestVisibilityCallback) {
+                        this.requestVisibilityCallback(true);
+                        console.log('📋 REQUEST VISIBILITY - Showing request wrapper');
+                    }
+                }
+                else if (requestStatus === false) {
+                    console.log('🚫 REQUEST DEBUG - Request is disabled for tabbing');
+                    // Hide request wrapper when request is disabled
+                    if (this.requestVisibilityCallback) {
+                        this.requestVisibilityCallback(false);
+                        console.log('📋 REQUEST VISIBILITY - Hiding request wrapper');
+                    }
+                }
+                else {
+                    console.log('⚠️ REQUEST DEBUG - Unexpected request status value:', requestStatus);
+                    // Default to hiding request wrapper for unexpected values
+                    if (this.requestVisibilityCallback) {
+                        this.requestVisibilityCallback(false);
+                        console.log('📋 REQUEST VISIBILITY - Hiding request wrapper (unexpected value)');
+                    }
+                }
+            }
+            else {
+                console.log('⚠️ REQUEST DEBUG - No request config found, tabs will not be created');
+                // Hide request wrapper when no request config found
+                if (this.requestVisibilityCallback) {
+                    this.requestVisibilityCallback(false);
+                    console.log('📋 REQUEST VISIBILITY - Hiding request wrapper (no config)');
+                }
+            }
+        }
+    }
+    /**
+     * Handle route changes - moved from request service for better architecture
+     * This method loads page data and calls request service to manage tabs
+     */
+    handleRouteChange() {
+        const parsedUrl = this.router.parseUrl(this.router.url);
+        const currentRoutePath = '/' + (parsedUrl.root.children['primary']?.segments.map(s => s.path).join('/') || '');
+        const queryParams = parsedUrl.queryParams;
+        console.log('🔍 Route change:', {
+            currentRoutePath,
+            queryParams
+        });
+        // Get page code from route data
+        let route = this.router.routerState.snapshot.root;
+        while (route.firstChild) {
+            route = route.firstChild;
+        }
+        const pageCode = route.data && route.data['sypg_page_code'];
+        console.log('📄 Processing route with page code:', pageCode);
+        if (pageCode) {
+            const entityId = this.appState.getActiveEntityId();
+            console.log(`📡 Loading and processing page data for pageCode: ${pageCode}`);
+            this.pageDataSubscription = this.loadAndProcessPageData({ sypg_page_code: pageCode, sytm_entity_id_syen: entityId || undefined }, {
+                forceRefresh: false,
+                setTitle: true,
+                setSidebarContext: true,
+                updateLayout: true
+            }).pipe(take(1))
+                .subscribe({
+                next: (page_data_response) => {
+                    const layout = page_data_response?.data?.theme?.sytm_layout;
+                    // Update sidedrawer with processed layout
+                    this.sidedrawerService.updateDrawerItems(layout);
+                    // Sync sidebar active menu with loaded page
+                    this.syncSidebarActiveMenu(page_data_response, pageCode);
+                    if (layout?.sytm_layout_request?.status === true) {
+                        console.log('✅ Layout processed - calling request service to manage tabs');
+                        // Call request service to handle tab creation
+                        this.handleTabRequest(currentRoutePath, queryParams, layout, page_data_response, pageCode);
+                    }
+                    else {
+                        console.log('❌ Layout request disabled - tab not created');
+                    }
+                },
+                error: (err) => {
+                    console.error(`❌ Error loading page data for sypg_page_code '${pageCode}':`, err);
+                    this.sidedrawerService.updateDrawerItems(undefined);
+                }
+            });
+        }
+        else {
+            console.log('⚠️ No page code found in route data - clearing drawer');
+            this.sidedrawerService.updateDrawerItems(undefined);
+        }
+    }
+    /**
+     * Handle tab request by calling request service
+     */
+    handleTabRequest(currentRoutePath, queryParams, layout, pageData, pageCode) {
+        if (this.tabManagementCallback) {
+            console.log('🔄 Calling registered tab management callback');
+            this.tabManagementCallback(currentRoutePath, queryParams, layout, pageData, pageCode);
+        }
+        else {
+            console.log('⚠️ No tab management callback registered');
+        }
+    }
+    /**
+     * Sync the active menu in the sidebar based on the loaded page data.
+     * This ensures the correct module is highlighted in the sidebar.
+     */
+    syncSidebarActiveMenu(page_data_response, pageCode) {
+        console.log('🔍 SIDEBAR SYNC: Starting sidebar active menu sync for:', pageCode);
+        // Try to extract module information from route
+        const currentRoute = this.router.url;
+        const routeParts = currentRoute.split('/').filter(part => part);
+        let routeModuleName = '';
+        // Look for control-panel or module identifier in route
+        if (routeParts.includes('control-panel') && routeParts.length > 1) {
+            const moduleIndex = routeParts.indexOf('control-panel') + 1;
+            routeModuleName = routeParts[moduleIndex] || '';
+        }
+        else if (routeParts.length > 0) {
+            routeModuleName = routeParts[0];
+        }
+        console.log('🔍 SIDEBAR SYNC: Route module name:', routeModuleName);
+        console.log('🔍 SIDEBAR SYNC: Current route:', currentRoute);
+        console.log('🔍 SIDEBAR SYNC: Page code:', pageCode);
+        // Load sidebar modules and find the matching one
+        this.sidebarService.getSidebarMenues({ syme_type: "module", sort: 'asc', syme_title: "" })
+            .subscribe({
+            next: (modulesResponse) => {
+                const modules = modulesResponse?.data || [];
+                console.log('🔍 SIDEBAR SYNC: Available modules:', modules.map(m => ({ id: m._id, title: m.syme_title, path: m.syme_path })));
+                let matchedModule = null;
+                // Try to match by route path
+                if (routeModuleName) {
+                    matchedModule = modules.find(m => m.syme_path?.includes(routeModuleName) ||
+                        m.syme_title?.toLowerCase().includes(routeModuleName.toLowerCase()) ||
+                        routeModuleName.includes(m.syme_path || '') ||
+                        m.syme_path === routeModuleName);
+                    if (matchedModule) {
+                        console.log('✅ SIDEBAR SYNC: Matched module by route:', matchedModule.syme_title);
+                    }
+                }
+                // If not found, try to match by page code pattern
+                if (!matchedModule && pageCode) {
+                    matchedModule = modules.find(m => pageCode.includes(m.syme_path || '') ||
+                        (m.syme_path && pageCode.toLowerCase().includes(m.syme_path.toLowerCase())) ||
+                        m.syme_path === pageCode);
+                    if (matchedModule) {
+                        console.log('✅ SIDEBAR SYNC: Matched module by page code:', matchedModule.syme_title);
+                    }
+                }
+                // If still not found, try partial matching for common patterns
+                if (!matchedModule) {
+                    // Try to match common patterns like 'admin', 'dashboard', etc.
+                    const searchTerms = [routeModuleName, pageCode].filter(Boolean);
+                    for (const term of searchTerms) {
+                        matchedModule = modules.find(m => m.syme_title?.toLowerCase().includes(term.toLowerCase()) ||
+                            term.toLowerCase().includes(m.syme_title?.toLowerCase() || '') ||
+                            m.syme_path?.toLowerCase().includes(term.toLowerCase()) ||
+                            term.toLowerCase().includes(m.syme_path?.toLowerCase() || ''));
+                        if (matchedModule) {
+                            console.log('✅ SIDEBAR SYNC: Matched module by pattern:', matchedModule.syme_title, 'for term:', term);
+                            break;
+                        }
+                    }
+                }
+                // Check if we should set the matched module as active
+                if (matchedModule) {
+                    const currentActiveModule = this.appState.getActiveModule();
+                    // Be more conservative about overriding user selections
+                    // Only set the module if no module is currently active
+                    const shouldSetModule = !currentActiveModule;
+                    if (shouldSetModule) {
+                        console.log('🎯 SIDEBAR SYNC: No active module, setting:', matchedModule.syme_title, matchedModule._id);
+                        this.appState.setActiveModule(matchedModule);
+                    }
+                    else {
+                        console.log('✅ SIDEBAR SYNC: Module already active, respecting user selection:', currentActiveModule?.syme_title);
+                        console.log('🔍 SIDEBAR SYNC: Route suggests:', matchedModule.syme_title, '- not overriding');
+                    }
+                }
+                else {
+                    console.log('⚠️ SIDEBAR SYNC: No matching module found for page:', pageCode);
+                    console.log('🔍 SIDEBAR SYNC: Available modules:', modules.map(m => m.syme_title).join(', '));
+                    console.log('🔍 SIDEBAR SYNC: Searched for route:', routeModuleName, 'and page code:', pageCode);
+                }
+            },
+            error: (err) => {
+                console.error('❌ SIDEBAR SYNC: Error loading modules for sync:', err);
+            }
+        });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytSharedService, deps: [{ token: i1.CideElementsService }, { token: i2.HttpClient }, { token: i3.Title }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytSharedService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytSharedService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CideLytSharedService, decorators: [{
@@ -28,5 +504,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: i1.CideElementsService }, { type: i2.HttpClient }, { type: i3.Title }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.service.js","sourceRoot":"","sources":["../../../../../../projects/cloud-ide-layout/src/lib/layout/shared/shared.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, signal, computed } from '@angular/core';\nimport { cidePath, designConfigControllerResponse, designConfigRoutesUrl, hostManagerRoutesUrl, ISytmLayout, MDesignConfig } from 'cloud-ide-lms-model';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, of, throwError, Subscription } from 'rxjs';\nimport { tap, catchError, shareReplay, filter, take } from 'rxjs/operators';\nimport { Router, NavigationEnd } from '@angular/router';\nimport { Title } from '@angular/platform-browser';\nimport { CideElementsService } from 'cloud-ide-element';\nimport { CideLytSidebarService } from '../sidebar/sidebar.service';\nimport { CideLytSharedWrapperSetupParam } from './shared-wrapper/shared-wrapper.component';\nimport { CideLytHeaderService } from '../header/header.service';\nimport { CideLytFooterService } from '../footer/footer.service';\nimport { CideLytConsoleService } from '../console/console.service';\nimport { CideLytSidedrawerService } from '../sidedrawer/sidedrawer.service';\nimport { AppStateHelperService } from '../../services/app-state/app-state-helper.service';\n\n// Enhanced cache interface with TTL support\ninterface CachedPageData {\n  request: Partial<CideLytSharedWrapperSetupParam>;\n  response: designConfigControllerResponse;\n  timestamp: number;\n  ttl: number; // Time to live in milliseconds\n}\n\n// Loading state tracking\ntype LoadingState = { [key: string]: Observable<designConfigControllerResponse> };\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CideLytSharedService {\n  // Enhanced reactive cache with signals\n  private pageDataCacheSignal = signal<{ [key: string]: CachedPageData }>({});\n  private loadingStateSignal = signal<{ [key: string]: boolean }>({});\n  \n  // Public readonly access to cache\n  public readonly pageDataCache = this.pageDataCacheSignal.asReadonly();\n  public readonly loadingStates = this.loadingStateSignal.asReadonly();\n  \n  // Computed signal for cache status\n  public readonly cacheInfo = computed(() => {\n    const cache = this.pageDataCacheSignal();\n    return {\n      totalCached: Object.keys(cache).length,\n      validCached: Object.values(cache).filter(item => this.isCacheValid(item)).length,\n      expiredCached: Object.values(cache).filter(item => !this.isCacheValid(item)).length\n    };\n  });\n  \n  // In-flight requests to prevent duplicate API calls\n  private inflightRequests: LoadingState = {};\n  \n  // Default cache TTL (5 minutes)\n  private readonly DEFAULT_CACHE_TTL = 5 * 60 * 1000;\n  \n  // Modern Angular v20 dependency injection pattern\n  private elementService = inject(CideElementsService);\n  private http = inject(HttpClient);\n  public titleService = inject(Title);\n  private sidebarService = inject(CideLytSidebarService);\n  private headerService = inject(CideLytHeaderService);\n  private footerService = inject(CideLytFooterService);\n  private consoleService = inject(CideLytConsoleService);\n  private sidedrawerService = inject(CideLytSidedrawerService);\n  private router = inject(Router);\n  \n  // Import AppStateHelperService for sidebar sync\n  private appState = inject(AppStateHelperService);\n  \n  // Route change subscription for cleanup\n  private routeSubscription?: Subscription;\n  private pageDataSubscription?: Subscription;\n  \n  // Tab management callback - to avoid circular dependency\n  private tabManagementCallback?: (\n    currentRoutePath: string,\n    queryParams: Record<string, unknown>,\n    layout: ISytmLayout,\n    pageData: designConfigControllerResponse,\n    pageCode: string\n  ) => void;\n  \n  // Request visibility callback\n  private requestVisibilityCallback?: (show: boolean) => void;\n\n  constructor() {\n    // Clean up expired cache entries every minute\n    // setInterval(() => this.cleanExpiredCache(), 60000);\n    \n    // Listen to route changes - moved from request service\n    this.routeSubscription = this.router.events.pipe(\n      filter(event => event instanceof NavigationEnd)\n    ).subscribe(() => {\n      // Cancel any ongoing page data fetching\n      this.pageDataSubscription?.unsubscribe();\n      this.handleRouteChange();\n    });\n  }\n\n  /**\n   * Register tab management callback from request service\n   * This allows shared service to call request service without circular dependency\n   */\n  registerTabManagement(callback: (\n    currentRoutePath: string,\n    queryParams: Record<string, unknown>,\n    layout: ISytmLayout,\n    pageData: designConfigControllerResponse,\n    pageCode: string\n  ) => void) {\n    this.tabManagementCallback = callback;\n    console.log('✅ Tab management callback registered');\n  }\n\n  /**\n   * Register request visibility callback from request service\n   * This allows shared service to control request wrapper visibility\n   */\n  registerRequestVisibility(callback: (show: boolean) => void) {\n    this.requestVisibilityCallback = callback;\n    console.log('✅ Request visibility callback registered');\n  }\n\n  /**\n   * Enhanced loadPageData with caching and deduplication\n   * @param body - Request payload\n   * @param forceRefresh - Force API call even if cached data exists\n   * @param customTTL - Custom cache TTL in milliseconds\n   */\n  loadPageData(\n    body: MDesignConfig, \n    forceRefresh: boolean = false, \n    customTTL: number = this.DEFAULT_CACHE_TTL\n  ): Observable<designConfigControllerResponse> {\n    const pageCode = body.sypg_page_code?.toString() || '';\n    \n    if (!pageCode) {\n      return throwError(() => new Error('Page code is required'));\n    }\n\n    // Check if we have valid cached data and not forcing refresh\n    if (!forceRefresh && this.hasValidCache(pageCode)) {\n      console.log(`🔄 CACHE HIT: Using cached data for page code: ${pageCode}`);\n      const cachedData = this.pageDataCacheSignal()[pageCode];\n      return of(cachedData.response);\n    }\n\n    // Check if there's already an in-flight request for this page code\n    if (this.inflightRequests[pageCode]) {\n      console.log(`🔄 INFLIGHT REQUEST: Returning existing request for page code: ${pageCode}`);\n      return this.inflightRequests[pageCode];\n    }\n\n    // Set loading state\n    this.setLoadingState(pageCode, true);\n\n    console.log(`🌐 API CALL: Loading fresh data for page code: ${pageCode}`);\n    \n    // Create new API request\n    const request$ = this.http.post(\n      cidePath.join([hostManagerRoutesUrl.cideSuiteHost, designConfigRoutesUrl?.module, designConfigRoutesUrl?.getPageData]), \n      body\n    ) as Observable<designConfigControllerResponse>;\n\n    // Cache the observable to prevent duplicate requests\n    this.inflightRequests[pageCode] = request$.pipe(\n      tap(response => {\n        console.log(`✅ API SUCCESS: Caching data for page code: ${pageCode}`);\n        this.cachePageData(pageCode, body, response, customTTL);\n        this.setLoadingState(pageCode, false);\n      }),\n      catchError(error => {\n        console.error(`❌ API ERROR: Failed to load data for page code: ${pageCode}`, error);\n        this.setLoadingState(pageCode, false);\n        return throwError(() => error);\n      }),\n      shareReplay(1) // Share the result with multiple subscribers\n    );\n\n    // Clean up inflight request after completion\n    this.inflightRequests[pageCode].subscribe({\n      complete: () => {\n        delete this.inflightRequests[pageCode];\n      },\n      error: () => {\n        delete this.inflightRequests[pageCode];\n      }\n    });\n\n    return this.inflightRequests[pageCode];\n  }\n\n  /**\n   * Consolidated method to load and process page data\n   * This replaces the separate calls in request service and shared wrapper\n   */\n  loadAndProcessPageData(\n    body: MDesignConfig, \n    options: {\n      forceRefresh?: boolean;\n      customTTL?: number;\n      setTitle?: boolean;\n      setSidebarContext?: boolean;\n      updateLayout?: boolean;\n    } = {}\n  ): Observable<designConfigControllerResponse> {\n    const {\n      forceRefresh = false,\n      customTTL = this.DEFAULT_CACHE_TTL,\n      setTitle = true,\n      setSidebarContext = true,\n      updateLayout = true\n    } = options;\n\n    return this.loadPageData(body, forceRefresh, customTTL).pipe(\n      tap(response => {\n        if (response) {\n          console.log('🔍 SHARED SERVICE: loadAndProcessPageData', response);\n          // Process the response\n          if (updateLayout) {\n            this.setPageData(response, body);\n          }\n          \n          // Set page title\n          if (setTitle && response.data?.page?.sypg_title) {\n            this.titleService.setTitle(response.data.page.sypg_title);\n          }\n          \n          // Set sidebar context\n          if (setSidebarContext) {\n            // This will be handled by the component that needs the context\n            // as it's specific to the sidedrawer service\n          }\n        }\n      })\n    );\n  }\n\n  /**\n   * Get cached page data without making API call\n   */\n  getCachedPageData(pageCode: string): designConfigControllerResponse | null {\n    const cached = this.pageDataCacheSignal()[pageCode];\n    return this.isCacheValid(cached) ? cached.response : null;\n  }\n\n  /**\n   * Check if loading for a specific page code\n   */\n  isLoading(pageCode: string): boolean {\n    return this.loadingStates()[pageCode] || false;\n  }\n\n  /**\n   * Invalidate cache for specific page code\n   */\n  invalidateCache(pageCode: string): void {\n    const cache = { ...this.pageDataCacheSignal() };\n    delete cache[pageCode];\n    this.pageDataCacheSignal.set(cache);\n    console.log(`🗑️ CACHE INVALIDATED: Removed cache for page code: ${pageCode}`);\n  }\n\n  /**\n   * Clear all cached data\n   */\n  clearAllCache(): void {\n    this.pageDataCacheSignal.set({});\n    this.loadingStateSignal.set({});\n    console.log('🗑️ CACHE CLEARED: All cached data removed');\n  }\n\n  /**\n   * Preload page data for better performance\n   */\n  preloadPageData(pageCodes: string[]): void {\n    pageCodes.forEach(pageCode => {\n      if (!this.hasValidCache(pageCode) && !this.isLoading(pageCode)) {\n        this.loadPageData({ sypg_page_code: pageCode }).subscribe({\n          next: () => console.log(`🚀 PRELOADED: Page data for ${pageCode}`),\n          error: (err) => console.warn(`⚠️ PRELOAD FAILED: Could not preload ${pageCode}`, err)\n        });\n      }\n    });\n  }\n\n  // Private helper methods\n  private hasValidCache(pageCode: string): boolean {\n    const cached = this.pageDataCacheSignal()[pageCode];\n    return cached && this.isCacheValid(cached);\n  }\n\n  private isCacheValid(cached: CachedPageData | undefined): boolean {\n    if (!cached) return false;\n    return Date.now() - cached.timestamp < cached.ttl;\n  }\n\n  private cachePageData(\n    pageCode: string, \n    request: MDesignConfig, \n    response: designConfigControllerResponse, \n    ttl: number\n  ): void {\n    const cache = { ...this.pageDataCacheSignal() };\n    cache[pageCode] = {\n      request,\n      response,\n      timestamp: Date.now(),\n      ttl\n    };\n    this.pageDataCacheSignal.set(cache);\n  }\n\n  private setLoadingState(pageCode: string, loading: boolean): void {\n    const loadingStates = { ...this.loadingStateSignal() };\n    if (loading) {\n      loadingStates[pageCode] = true;\n    } else {\n      delete loadingStates[pageCode];\n    }\n    this.loadingStateSignal.set(loadingStates);\n  }\n\n  private cleanExpiredCache(): void {\n    const cache = { ...this.pageDataCacheSignal() };\n    let cleaned = false;\n    \n    Object.keys(cache).forEach(pageCode => {\n      if (!this.isCacheValid(cache[pageCode])) {\n        delete cache[pageCode];\n        cleaned = true;\n      }\n    });\n    \n    if (cleaned) {\n      this.pageDataCacheSignal.set(cache);\n      console.log('🧹 CACHE CLEANUP: Removed expired cache entries');\n    }\n  }\n\n  setPageData(page_data_response: designConfigControllerResponse, page_data_payload: Partial<CideLytSharedWrapperSetupParam>): void {\n    // to set the controls data to the element service\n    console.log('🔍 SHARED SERVICE: setPageData', page_data_response, page_data_payload);\n    if (page_data_response?.data?.controls) {\n      // Set controls here\n      this.elementService.cide_element_data = { ...this.elementService.cide_element_data, ...page_data_response?.data?.controls };\n      this.elementService.is_cide_element_data_updated?.next(true);\n    }\n\n    // while doing this we need to think about not to touch if this page is not pening in the popup or drower insted of main window\n    // Set the layout data\n    console.log('🔍 Layout data:', page_data_response);\n    if (page_data_response?.data?.theme?.sytm_layout) {\n      console.log('🔍 SIDEBAR DEBUG - Layout data:', page_data_response?.data?.theme?.sytm_layout, page_data_payload);\n      // check is sidebar is hiden or not (default is visible)\n      if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_sidebar) {\n        const sidebarStatus = page_data_response?.data?.theme?.sytm_layout?.sytm_layout_sidebar?.status;\n        console.log('🔍 SIDEBAR DEBUG - Sidebar status found:', sidebarStatus);\n        if (!sidebarStatus) {\n          console.log('🚫 SIDEBAR DEBUG - Hiding sidebar because status is false');\n          this.sidebarService.hideSidebar();\n        } else {\n          console.log('✅ SIDEBAR DEBUG - Showing sidebar because status is true');\n          this.sidebarService.showSidebar();\n        }\n      } else {\n        console.log('⚠️ SIDEBAR DEBUG - No sidebar config found, hiding sidebar');\n        this.sidebarService.hideSidebar();\n      }\n\n      // check header visible or not\n      console.log('🔍 HEADER DEBUG - Header config found:', page_data_response?.data?.theme?.sytm_layout?.sytm_layout_header);\n      if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_header) {\n        if (!page_data_response?.data?.theme?.sytm_layout?.sytm_layout_header?.status) {\n          this.headerService.hideHeader();\n        } else {\n          this.headerService.showHeader();\n        }\n      } else {\n        this.headerService.hideHeader();\n      }\n\n      // check footer visible or not \n      if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_footer) {\n        if (!page_data_response?.data?.theme?.sytm_layout?.sytm_layout_footer?.status) {\n          this.footerService.hideFooter();\n        } else {\n          this.footerService.showFooter();\n        }\n      } else {\n        this.footerService.hideFooter();\n      }\n\n      // check console visible or not\n      if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_console) {\n        if (!page_data_response?.data?.theme?.sytm_layout?.sytm_layout_console?.status) {\n          this.consoleService.hideConsole();\n        } else {\n          this.consoleService.showConsole();\n        }\n      } else {\n        this.consoleService.hideConsole();\n      }\n\n      // check for the request status and log it for debugging\n      console.log('🔍 REQUEST DEBUG - Request config found:', page_data_response?.data?.theme?.sytm_layout?.sytm_layout_request);\n      if (page_data_response?.data?.theme?.sytm_layout?.sytm_layout_request) {\n        const requestStatus = page_data_response?.data?.theme?.sytm_layout?.sytm_layout_request?.status;\n        console.log('🔍 REQUEST DEBUG - Request status:', requestStatus, 'Type:', typeof requestStatus);\n        \n        // The request status controls whether this page should support tabs\n        // This is used by the request service to determine if tabs should be created\n        if (requestStatus === true) {\n          console.log('✅ REQUEST DEBUG - Request is enabled for tabbing');\n          // Show request wrapper when request is enabled\n          if (this.requestVisibilityCallback) {\n            this.requestVisibilityCallback(true);\n            console.log('📋 REQUEST VISIBILITY - Showing request wrapper');\n          }\n        } else if (requestStatus === false) {\n          console.log('🚫 REQUEST DEBUG - Request is disabled for tabbing');\n          // Hide request wrapper when request is disabled\n          if (this.requestVisibilityCallback) {\n            this.requestVisibilityCallback(false);\n            console.log('📋 REQUEST VISIBILITY - Hiding request wrapper');\n          }\n        } else {\n          console.log('⚠️ REQUEST DEBUG - Unexpected request status value:', requestStatus);\n          // Default to hiding request wrapper for unexpected values\n          if (this.requestVisibilityCallback) {\n            this.requestVisibilityCallback(false);\n            console.log('📋 REQUEST VISIBILITY - Hiding request wrapper (unexpected value)');\n          }\n        }\n      } else {\n        console.log('⚠️ REQUEST DEBUG - No request config found, tabs will not be created');\n        // Hide request wrapper when no request config found\n        if (this.requestVisibilityCallback) {\n          this.requestVisibilityCallback(false);\n          console.log('📋 REQUEST VISIBILITY - Hiding request wrapper (no config)');\n        }\n      }\n    }\n\n  }\n\n  /**\n   * Handle route changes - moved from request service for better architecture\n   * This method loads page data and calls request service to manage tabs\n   */\n  private handleRouteChange() {\n    const parsedUrl = this.router.parseUrl(this.router.url);\n    const currentRoutePath = '/' + (parsedUrl.root.children['primary']?.segments.map(s => s.path).join('/') || '');\n    const queryParams = parsedUrl.queryParams;\n\n    console.log('🔍 Route change:', {\n      currentRoutePath,\n      queryParams\n    });\n\n    // Get page code from route data\n    let route = this.router.routerState.snapshot.root;\n    while (route.firstChild) {\n      route = route.firstChild;\n    }\n\n    const pageCode = route.data && route.data['sypg_page_code'];\n    console.log('📄 Processing route with page code:', pageCode);\n\n    if (pageCode) {\n      const entityId = this.appState.getActiveEntityId();\n      console.log(`📡 Loading and processing page data for pageCode: ${pageCode}`);\n      this.pageDataSubscription = this.loadAndProcessPageData(\n        { sypg_page_code: pageCode, sytm_entity_id_syen: entityId || undefined },\n        {\n          forceRefresh: false,\n          setTitle: true,\n          setSidebarContext: true,\n          updateLayout: true\n        }\n      ).pipe(take(1))\n        .subscribe({\n          next: (page_data_response) => {\n            const layout = page_data_response?.data?.theme?.sytm_layout;\n            \n            // Update sidedrawer with processed layout\n            this.sidedrawerService.updateDrawerItems(layout);\n            \n            // Sync sidebar active menu with loaded page\n            this.syncSidebarActiveMenu(page_data_response, pageCode);\n            \n            if (layout?.sytm_layout_request?.status === true) {\n              console.log('✅ Layout processed - calling request service to manage tabs');\n              // Call request service to handle tab creation\n              this.handleTabRequest(currentRoutePath, queryParams, layout, page_data_response, pageCode);\n            } else {\n              console.log('❌ Layout request disabled - tab not created');\n            }\n          },\n          error: (err) => {\n            console.error(`❌ Error loading page data for sypg_page_code '${pageCode}':`, err);\n            this.sidedrawerService.updateDrawerItems(undefined);\n          }\n        });\n    } else {\n      console.log('⚠️ No page code found in route data - clearing drawer');\n      this.sidedrawerService.updateDrawerItems(undefined);\n    }\n  }\n\n  /**\n   * Handle tab request by calling request service\n   */\n  private handleTabRequest(\n    currentRoutePath: string, \n    queryParams: Record<string, unknown>, \n    layout: ISytmLayout, \n    pageData: designConfigControllerResponse, \n    pageCode: string\n  ) {\n    if (this.tabManagementCallback) {\n      console.log('🔄 Calling registered tab management callback');\n      this.tabManagementCallback(currentRoutePath, queryParams, layout, pageData, pageCode);\n    } else {\n      console.log('⚠️ No tab management callback registered');\n    }\n  }\n\n  /**\n   * Sync the active menu in the sidebar based on the loaded page data.\n   * This ensures the correct module is highlighted in the sidebar.\n   */\n  private syncSidebarActiveMenu(page_data_response: designConfigControllerResponse, pageCode: string): void {\n    console.log('🔍 SIDEBAR SYNC: Starting sidebar active menu sync for:', pageCode);\n    \n    // Try to extract module information from route\n    const currentRoute = this.router.url;\n    const routeParts = currentRoute.split('/').filter(part => part);\n    let routeModuleName = '';\n    \n    // Look for control-panel or module identifier in route\n    if (routeParts.includes('control-panel') && routeParts.length > 1) {\n      const moduleIndex = routeParts.indexOf('control-panel') + 1;\n      routeModuleName = routeParts[moduleIndex] || '';\n    } else if (routeParts.length > 0) {\n      routeModuleName = routeParts[0];\n    }\n    \n    console.log('🔍 SIDEBAR SYNC: Route module name:', routeModuleName);\n    console.log('🔍 SIDEBAR SYNC: Current route:', currentRoute);\n    console.log('🔍 SIDEBAR SYNC: Page code:', pageCode);\n    \n    // Load sidebar modules and find the matching one\n    this.sidebarService.getSidebarMenues({ syme_type: \"module\", sort: 'asc', syme_title: \"\" })\n      .subscribe({\n        next: (modulesResponse) => {\n          const modules = modulesResponse?.data || [];\n          console.log('🔍 SIDEBAR SYNC: Available modules:', modules.map(m => ({ id: m._id, title: m.syme_title, path: m.syme_path })));\n          \n          let matchedModule = null;\n          \n          // Try to match by route path\n          if (routeModuleName) {\n            matchedModule = modules.find(m => \n              m.syme_path?.includes(routeModuleName) || \n              m.syme_title?.toLowerCase().includes(routeModuleName.toLowerCase()) ||\n              routeModuleName.includes(m.syme_path || '') ||\n              m.syme_path === routeModuleName\n            );\n            if (matchedModule) {\n              console.log('✅ SIDEBAR SYNC: Matched module by route:', matchedModule.syme_title);\n            }\n          }\n          \n          // If not found, try to match by page code pattern\n          if (!matchedModule && pageCode) {\n            matchedModule = modules.find(m => \n              pageCode.includes(m.syme_path || '') ||\n              (m.syme_path && pageCode.toLowerCase().includes(m.syme_path.toLowerCase())) ||\n              m.syme_path === pageCode\n            );\n            if (matchedModule) {\n              console.log('✅ SIDEBAR SYNC: Matched module by page code:', matchedModule.syme_title);\n            }\n          }\n          \n          // If still not found, try partial matching for common patterns\n          if (!matchedModule) {\n            // Try to match common patterns like 'admin', 'dashboard', etc.\n            const searchTerms = [routeModuleName, pageCode].filter(Boolean);\n            for (const term of searchTerms) {\n              matchedModule = modules.find(m => \n                m.syme_title?.toLowerCase().includes(term.toLowerCase()) ||\n                term.toLowerCase().includes(m.syme_title?.toLowerCase() || '') ||\n                m.syme_path?.toLowerCase().includes(term.toLowerCase()) ||\n                term.toLowerCase().includes(m.syme_path?.toLowerCase() || '')\n              );\n              if (matchedModule) {\n                console.log('✅ SIDEBAR SYNC: Matched module by pattern:', matchedModule.syme_title, 'for term:', term);\n                break;\n              }\n            }\n          }\n          \n          // Check if we should set the matched module as active\n          if (matchedModule) {\n            const currentActiveModule = this.appState.getActiveModule();\n            \n            // Be more conservative about overriding user selections\n            // Only set the module if no module is currently active\n            const shouldSetModule = !currentActiveModule;\n               \n            if (shouldSetModule) {\n              console.log('🎯 SIDEBAR SYNC: No active module, setting:', matchedModule.syme_title, matchedModule._id);\n              this.appState.setActiveModule(matchedModule);\n            } else {\n              console.log('✅ SIDEBAR SYNC: Module already active, respecting user selection:', currentActiveModule?.syme_title);\n              console.log('🔍 SIDEBAR SYNC: Route suggests:', matchedModule.syme_title, '- not overriding');\n            }\n          } else {\n            console.log('⚠️ SIDEBAR SYNC: No matching module found for page:', pageCode);\n            console.log('🔍 SIDEBAR SYNC: Available modules:', modules.map(m => m.syme_title).join(', '));\n            console.log('🔍 SIDEBAR SYNC: Searched for route:', routeModuleName, 'and page code:', pageCode);\n          }\n        },\n        error: (err) => {\n          console.error('❌ SIDEBAR SYNC: Error loading modules for sync:', err);\n        }\n      });\n  }\n\n}\n"]}