@sunbird-cb/cbp-ai 0.0.1

package/esm2022/lib/components/generate-course-recommendation/generate-course-recommendation.component.mjs

@@ -0,0 +1,1949 @@
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { Component, Inject, ViewChild } from '@angular/core';
+import { SuggestMoreCoursesComponent } from '../suggest-more-courses/suggest-more-courses.component';
+import { AddCourseComponent } from '../add-course/add-course.component';
+import html2pdf from 'html2pdf.js';
+import { interval, of } from 'rxjs';
+import { switchMap, takeWhile, tap, catchError, finalize } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "../../modules/shared/services/shared.service";
+import * as i3 from "@angular/material/snack-bar";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/legacy-form-field";
+import * as i7 from "@angular/material/legacy-input";
+import * as i8 from "@angular/material/legacy-button";
+import * as i9 from "@angular/material/icon";
+import * as i10 from "@angular/material/legacy-select";
+import * as i11 from "@angular/material/legacy-core";
+import * as i12 from "@angular/material/legacy-checkbox";
+import * as i13 from "@angular/material/progress-spinner";
+import * as i14 from "@angular/material/tabs";
+import * as i15 from "../gap-analysis-recommended-course/gap-analysis-recommended-course.component";
+export class GenerateCourseRecommendationComponent {
+    constructor(dialogRef, data, sharedService, snackBar, dialog, fb) {
+        this.dialogRef = dialogRef;
+        this.data = data;
+        this.sharedService = sharedService;
+        this.snackBar = snackBar;
+        this.dialog = dialog;
+        this.fb = fb;
+        this.loading = false;
+        this.dataLoaded = false; // Track if initial data has been loaded
+        this.isRegeneratingWithProgress = false; // Track regeneration with progress loading
+        this.recommended_course_id = '';
+        // Progressive loading for course generation
+        this.currentProcessingStage = '';
+        this.progressPercentage = 0;
+        this.processingStages = [
+            'Analyzing roles and responsibilities...',
+            'Detailing competency requirements...',
+            'Preparing iGOT course recommendations...',
+            'Generating public course suggestions...',
+            'Computing comprehensive gap analysis...',
+            'Finalizing course recommendation plan...'
+        ];
+        this.stageStartTime = 0;
+        this.searchText = '';
+        this.filterdCourses = [];
+        this.originalData = [];
+        this.selectFilterCourses = [];
+        this.suggestedCourses = []; // Track iGOT suggested courses separately
+        this.userAddedCourses = []; // Track user-added courses separately
+        this.mode = 'add';
+        this.cbp_plan_id = '';
+        this.expandedCompetencies = {}; // Track expanded state for each course and competency type
+        this.outerTabActiveIndex = 0;
+        this.innerTabActiveIndex = 0;
+        this.outerTabActiveText = 'all';
+        this.innerTabActiveText = 'all';
+        this.selectedCategory = 'all';
+        this.competencyCoveredCount = 0;
+        this.overallCoverage = 0;
+        this.behavioralCompetencyCoveredCount = 0;
+        this.behavioralTotalCompetencies = 0;
+        this.behavioralCoverage = 0;
+        this.functionalCompetencyCoveredCount = 0;
+        this.functionalTotalCompetencies = 0;
+        this.functionalCoverage = 0;
+        this.domainCompetencyCoveredCount = 0;
+        this.domainTotalCompetencies = 0;
+        this.domainCoverage = 0;
+        this.competencyNotMatchedByCategory = [];
+        this.competencyMatchedByCategory = [];
+        this.menuItems = [
+            { key: 'all', label: 'All Categories' },
+            { key: 'behavioral', label: 'Behavioural' },
+            { key: 'functional', label: 'Functional' },
+            { key: 'domain', label: 'Domain' }
+        ];
+        this.behaviouralNotMatched = [];
+        this.functionalNotMatched = [];
+        this.domainNotMatched = [];
+        this.selectedThemeFilter = '';
+        this.originalFilteredCourses = [];
+        this.isRegenerating = false;
+        this.isPDFDownload = false;
+        this.behaviouralMatched = [];
+        this.functionalMatched = [];
+        this.domainMatched = [];
+        this.competenciesType = ['All', 'Behavioural', 'Functional', 'Domain'];
+        this.ratings = ['4.5 and above', '4.0 and above', '3.5 and above', '2.5 and above', '1 and above'];
+        this.languages = ['English', 'Hindi', 'Tamil', 'Kannada', 'Telugu', 'Malayalam', 'Assamese', 'Bengali', 'Gujarati', 'Marathi', 'Odia', 'Punjabi', 'Konkani', 'Bodo', 'Dogri', 'Kashmiri', 'Maithili', 'Manipuri', 'Nepali', 'Sanskrit', 'Santali', 'Sindhi', 'Urdu'];
+        this.durations = ['< 1 Hour', '1-5 Hours', '5+ Hours'];
+        this.providers = [];
+        this.filteredCompetency = [...this.competenciesType];
+        this.filteredRatings = [...this.ratings];
+        this.filteredLanguages = [...this.languages];
+        this.filteredDurations = [...this.durations];
+        this.filteredProviders = [...this.providers];
+        this.fullCourseList = [];
+        // Selected filters
+        this.selectedCompetency = 'All';
+        this.selectedRating = null;
+        this.selectedLanguage = null;
+        this.selectedDuration = null;
+        this.selectedProvider = null;
+        this.planData = data;
+    }
+    selectCategory(category) {
+        this.selectedCategory = category;
+        this.gapAnalysisStats();
+    }
+    ngOnInit() {
+        this.filterForm = this.fb.group({
+            competency: [[]],
+            rating: [[]],
+            language: [[]],
+            duration: [[]],
+            provider: [[]]
+        });
+        this.loadComponentData();
+    }
+    applyFilter(value) {
+        console.log('this.searchText', value);
+        this.searchText = value;
+        this.filterdCourses = this.filterData(this.searchText);
+    }
+    searchData() {
+        //  this.filterdCourses = this.filterData(this.searchText);
+    }
+    selectedFilterCourses(event, item) {
+        console.log('event', event);
+        console.log('item', item);
+        if (event.checked) {
+            if (this.selectFilterCourses.indexOf(item?.identifier) < 0) {
+                this.selectFilterCourses.push(item?.identifier);
+            }
+        }
+        else {
+            const index = this.selectFilterCourses.findIndex(control => control === item.identifier);
+            if (index !== -1) {
+                this.selectFilterCourses.splice(index, 1);
+            }
+        }
+        console.log('this.selectFilterCourses', this.selectFilterCourses);
+    }
+    closeDialog() {
+        this.dialogRef.close();
+    }
+    saveCourses() {
+        this.loading = true;
+        console.log('this.planData', this.planData);
+        let reqBody = {
+            "role_mapping_id": this.planData.id,
+            "recommended_course_id": this.recommended_course_id,
+            "course_identifiers": this.selectFilterCourses
+        };
+        console.log('reqBody, ', reqBody);
+        if (this.mode === 'add') {
+            this.sharedService.saveCourse(reqBody).subscribe({
+                next: (res) => {
+                    // Success handling
+                    console.log('Success:', res);
+                    this.loading = false;
+                    this.dialogRef.close('saved');
+                    this.snackBar.open('Courses Saved Successfully', 'X', {
+                        duration: 3000,
+                        panelClass: ['snackbar-success']
+                    });
+                    //this.successRoleMapping.emit(this.roleMappingForm)
+                },
+                error: (error) => {
+                    console.log('error', error);
+                    this.dialogRef.close();
+                    // Handle 409 Conflict here
+                    // alert('Conflict detected: The resource already exists or action conflicts.');
+                    //this.get
+                    // Or you can set a UI error message variable
+                    this.snackBar.open(error?.error?.detail, 'X', {
+                        duration: 3000,
+                        panelClass: ['snackbar-error']
+                    });
+                    this.loading = false;
+                    //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)
+                }
+            });
+        }
+        else {
+            if (this.cbp_plan_id) {
+                this.sharedService.updateCourse(reqBody, this.cbp_plan_id).subscribe({
+                    next: (res) => {
+                        // Success handling
+                        console.log('Success:', res);
+                        this.loading = false;
+                        this.dialogRef.close('saved');
+                        this.snackBar.open('Courses Updated Successfully', 'X', {
+                            duration: 3000,
+                            panelClass: ['snackbar-success']
+                        });
+                        //this.successRoleMapping.emit(this.roleMappingForm)
+                    },
+                    error: (error) => {
+                        console.log('error', error);
+                        this.dialogRef.close();
+                        // Handle 409 Conflict here
+                        // alert('Conflict detected: The resource already exists or action conflicts.');
+                        //this.get
+                        // Or you can set a UI error message variable
+                        this.snackBar.open(error?.error?.detail, 'X', {
+                            duration: 3000,
+                            panelClass: ['snackbar-error']
+                        });
+                        this.loading = false;
+                        //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)
+                    }
+                });
+            }
+            else {
+                // Handle case when cbp_plan_id is not available
+                this.loading = false;
+                console.error('cbp_plan_id is not available for update operation');
+                this.snackBar.open('Unable to update courses: missing plan ID', 'X', {
+                    duration: 3000,
+                    panelClass: ['snackbar-error']
+                });
+            }
+        }
+    }
+    getCourses() {
+        let role_mapping_id = this.planData.id;
+        this.loading = true;
+        this.sharedService.getCourse(role_mapping_id).subscribe({
+            next: (res) => {
+                // Success handling
+                this.loading = false;
+                console.log('res', res);
+                this.cbp_plan_id = res?.id;
+                if (res && res?.selected_courses && res?.selected_courses?.length) {
+                    this.mode = 'edit';
+                    for (let i = 0; i < res?.selected_courses.length; i++) {
+                        this.selectFilterCourses.push(res.selected_courses[i]?.identifier);
+                    }
+                }
+                //this.successRoleMapping.emit(this.roleMappingForm)
+            },
+            error: (error) => {
+                console.log('error', error);
+                this.loading = false;
+                // Handle 409 Conflict here
+                // alert('Conflict detected: The resource already exists or action conflicts.');
+                //this.get
+                // Or you can set a UI error message variable
+                this.loading = false;
+                //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)
+            }
+        });
+    }
+    getSuggestedCourse() {
+        let role_mapping_id = this.planData.id;
+        this.loading = true;
+        this.sharedService.getSuggestedCourses(role_mapping_id).subscribe({
+            next: (res) => {
+                // Success handling
+                this.loading = false;
+                console.log('getSuggestedCourses res', res);
+                console.log('this.filterdCourses', this.filterdCourses);
+                // Store suggested courses separately
+                this.suggestedCourses = [...res];
+                // Rebuild filterdCourses to include all course types
+                this.rebuildFilteredCourses();
+                // Update gap analysis stats after suggested courses are added
+                this.updateGapAnalysisAfterCoursesUpdate();
+                //this.successRoleMapping.emit(this.roleMappingForm)
+            },
+            error: (error) => {
+                console.log('error', error);
+                this.loading = false;
+                if (error.status === 401) {
+                    console.log('Unauthorized access - user will be redirected to login');
+                }
+                else {
+                    // Handle other errors gracefully
+                    console.error('Failed to load suggested courses');
+                }
+                // Or you can set a UI error message variable
+                this.loading = false;
+                //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)
+            }
+        });
+    }
+    getUserCourse() {
+        let role_mapping_id = this.planData.id;
+        this.loading = true;
+        this.sharedService.getUserCourse(role_mapping_id).subscribe({
+            next: (res) => {
+                // Success handling
+                this.loading = false;
+                console.log('getUserCourse API response:', res);
+                console.log('Current filterdCourses before adding user courses:', this.filterdCourses);
+                // Store user-added courses separately (reset to avoid duplicates)
+                this.userAddedCourses = [...res];
+                // Process user-added courses to ensure proper structure
+                for (let i = 0; i < res.length; i++) {
+                    const userCourse = res[i];
+                    console.log(`User course ${i} competencies:`, userCourse.competencies);
+                    // Ensure user-added courses have the expected structure for display
+                    if (userCourse && !userCourse.course_type) {
+                        userCourse.course_type = 'User Added';
+                    }
+                    // Add identifier if missing (needed for course selection logic)
+                    if (userCourse && !userCourse.identifier) {
+                        userCourse.identifier = userCourse.id || `user_course_${i}_${Date.now()}`;
+                    }
+                }
+                // Rebuild filterdCourses to include all course types
+                this.rebuildFilteredCourses();
+                console.log('filterdCourses after adding user courses:', this.filterdCourses);
+                //this.successRoleMapping.emit(this.roleMappingForm)
+            },
+            error: (error) => {
+                console.log('error', error);
+                this.loading = false;
+                // Handle 409 Conflict here
+                // alert('Conflict detected: The resource already exists or action conflicts.');
+                //this.get
+                // Or you can set a UI error message variable
+                this.loading = false;
+                //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)
+            }
+        });
+    }
+    checkIfCourseExists(item) {
+        let flag = false;
+        if (this.selectFilterCourses.indexOf(item?.identifier) > -1) {
+            flag = true;
+        }
+        return flag;
+    }
+    selectAllCourses(event) {
+        if (event.checked) {
+            for (let i = 0; i < this.filterdCourses.length; i++) {
+                this.selectFilterCourses.push(this.filterdCourses[i].identifier);
+            }
+        }
+        else {
+            this.selectFilterCourses = [];
+        }
+        if (this.cbp_plan_id) {
+            this.mode = 'update';
+        }
+        else {
+            this.mode = 'add';
+        }
+    }
+    getSectors(sector) {
+        if (sector && sector.length) {
+            return Array.isArray(sector) ? sector.join('/ ') : '';
+        }
+    }
+    filterData(searchText) {
+        const filter = searchText.trim().toLowerCase();
+        return this.originalData.filter(item => {
+            const stringified = this.flattenObjectToString(item).toLowerCase();
+            return stringified.includes(filter);
+        });
+    }
+    flattenObjectToString(obj) {
+        let result = '';
+        for (const key in obj) {
+            const value = obj[key];
+            if (typeof value === 'string') {
+                result += ' ' + value;
+            }
+            else if (Array.isArray(value)) {
+                value.forEach(val => {
+                    if (typeof val === 'string') {
+                        result += ' ' + val;
+                    }
+                    else if (typeof val === 'object') {
+                        result += ' ' + this.flattenObjectToString(val);
+                    }
+                });
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result += ' ' + this.flattenObjectToString(value);
+            }
+        }
+        return result;
+    }
+    suggestMoreCourses() {
+        // this.dialogRef.close()
+        const dialogRefNew = this.dialog.open(SuggestMoreCoursesComponent, {
+            width: '1000px',
+            data: { recommended_course_id: this.recommended_course_id, role_mapping_id: this.planData.id },
+            panelClass: 'view-cbp-plan-popup',
+            minHeight: '400px',
+            maxHeight: '90vh',
+            disableClose: true // Optional: prevent closing with outside click
+        });
+        dialogRefNew.afterClosed().subscribe(result => {
+            if (result === 'saved') {
+                console.log('Changes saved!');
+                // Refresh data or show a toast here
+                this.getSuggestedCourse();
+            }
+            else {
+                this.getSuggestedCourse();
+            }
+        });
+    }
+    generateCourseRecommendation(element) {
+        console.log('Generate Course Recommendation clicked', element);
+        // this.activeRowElement = element
+        console.log('Edit Role Mapping clicked', element);
+        // Navigate or open modal
+        console.log('View CBP Plan clicked', element);
+        const dialogRef = this.dialog.open(GenerateCourseRecommendationComponent, {
+            width: '1000px',
+            data: element,
+            panelClass: 'view-cbp-plan-popup',
+            minHeight: '400px',
+            maxHeight: '90vh',
+            disableClose: true // Optional: prevent closing with outside click
+        });
+        dialogRef.afterClosed().subscribe(result => {
+            if (result === 'saved') {
+                console.log('Changes saved!');
+                // Refresh data or show a toast here
+                console.log(this.sharedService.cbpPlanFinalObj);
+                if (this.sharedService.cbpPlanFinalObj && this.sharedService.cbpPlanFinalObj.ministry && this.sharedService.cbpPlanFinalObj.ministry.id) {
+                    this.sharedService.getRoleMappingByStateCenter(this.sharedService.cbpPlanFinalObj.ministry.id).subscribe((res) => {
+                        console.log('res', res);
+                        // this.dataSource.data = res
+                        // this.dataSource.paginator = this.paginator;
+                        this.originalData = res;
+                        //  console.log('this.dataSource',this.dataSource)
+                    });
+                }
+                else {
+                }
+            }
+        });
+    }
+    getCompetenciesByType(type, index) {
+        const course = this.filterdCourses[index];
+        if (!course) {
+            console.log(`No course found at index ${index}`);
+            return [];
+        }
+        // Handle different competency property names
+        // AI Recommended & Public courses use 'competencies'
+        // Manually Suggested - iGOT courses use 'competencies_v6'
+        // User Added courses use 'competencies'
+        let competencies = [];
+        if (course.competencies && Array.isArray(course.competencies)) {
+            competencies = course.competencies;
+            //  console.log(`Course ${index} (${course.course_type || course.name || 'Unknown'}) using 'competencies' property:`, competencies);
+        }
+        else if (course.competencies_v6 && Array.isArray(course.competencies_v6)) {
+            competencies = course.competencies_v6;
+            // console.log(`Course ${index} (${course.course_type || course.name || 'Unknown'}) using 'competencies_v6' property:`, competencies);
+        }
+        else {
+            // console.log(`Course ${index} (${course.course_type || course.name || 'Unknown'}) has no valid competencies property:`, {
+            //   hasCompetencies: !!course.competencies,
+            //   competenciesType: typeof course.competencies,
+            //   hasCompetenciesV6: !!course.competencies_v6,
+            //   competenciesV6Type: typeof course.competencies_v6,
+            //   courseKeys: Object.keys(course)
+            // });
+        }
+        if (competencies.length === 0) {
+            //  console.log(`No competencies found for course ${index} and type ${type}`);
+            return [];
+        }
+        // Normalize the type for comparison (case-insensitive + handle spelling variations)
+        const normalizedType = type.toLowerCase().trim();
+        const matchedCompetencies = competencies.filter(c => {
+            if (!c || !c.competencyAreaName) {
+                console.log(`Invalid competency structure in course ${index}:`, c);
+                return false;
+            }
+            const competencyArea = c.competencyAreaName.toLowerCase().trim();
+            // Handle both "behavioral" and "behavioural" spellings
+            if (normalizedType === 'behavioural' || normalizedType === 'behavioral') {
+                return competencyArea === 'behavioral' || competencyArea === 'behavioural';
+            }
+            // For other types, do case-insensitive comparison
+            return competencyArea === normalizedType;
+        });
+        // console.log(`Found ${matchedCompetencies.length} competencies of type ${type} for course ${index}:`, matchedCompetencies);
+        return matchedCompetencies;
+    }
+    getCompetenciesByBehviouralType(index) {
+        const course = this.filterdCourses[index];
+        if (!course) {
+            return '';
+        }
+        // Handle different competency property names
+        let competencies = [];
+        if (course.competencies && Array.isArray(course.competencies)) {
+            competencies = course.competencies;
+        }
+        else if (course.competencies_v6 && Array.isArray(course.competencies_v6)) {
+            competencies = course.competencies_v6;
+        }
+        if (competencies.length === 0) {
+            return '';
+        }
+        return competencies
+            .filter(c => c && (c.competencyAreaName === 'Behavioral' || c.competencyAreaName === 'Behavioural'))
+            .map(c => `${c.competencyThemeName || ''} - ${c.competencySubThemeName || ''}`)
+            .join(', ');
+    }
+    getDisplayedCompetencies(type, index) {
+        const competencies = this.getCompetenciesByType(type, index);
+        const key = `${index}-${type}`;
+        if (this.expandedCompetencies[key]) {
+            return competencies;
+        }
+        return competencies.slice(0, 2);
+    }
+    toggleCompetencies(type, index) {
+        const key = `${index}-${type}`;
+        this.expandedCompetencies[key] = !this.expandedCompetencies[key];
+    }
+    isExpanded(type, index) {
+        const key = `${index}-${type}`;
+        return this.expandedCompetencies[key] || false;
+    }
+    hasMoreThanTwo(type, index) {
+        return this.getCompetenciesByType(type, index).length > 2;
+    }
+    getRemainingCount(type, index) {
+        const totalCount = this.getCompetenciesByType(type, index).length;
+        return totalCount - 2;
+    }
+    onOuterTabChange(event) {
+        this.outerTabActiveIndex = event.index;
+        this.outerTabActiveText = event.tab.textLabel;
+        console.log('Outer Tab Index:', event.index);
+        console.log('Outer Tab Label:', event.tab.textLabel);
+        if (event.index === 1) {
+            this.gapAnalysisStats();
+        }
+        if (event.index === 0) {
+            // this.getCourses()
+            // this.getSuggestedCourse()
+            this.getUserCourse();
+        }
+    }
+    onInnerTabChange(event) {
+        this.innerTabActiveIndex = event.index;
+        this.innerTabActiveText = event.tab.textLabel;
+        this.selectedThemeFilter = ''; // Reset theme filter when switching tabs
+        console.log('Inner Tab Index:', event.index);
+        console.log('Inner Tab Label:', event.tab.textLabel);
+        let tabIndex = event.index;
+        this.competencyMatchedByCategory = [];
+        // Get all available courses (original + suggested + user added)
+        const allAvailableCourses = this.getAllAvailableCourses();
+        switch (tabIndex) {
+            case 0: // All
+                this.filterdCourses = allAvailableCourses;
+                break;
+            case 1: // Behavioral
+                this.filterdCourses = this.behavioralFilter(allAvailableCourses);
+                this.competencyMatchedByCategory = this.behavioralCompetencyFilter(this.planData.competencies);
+                break;
+            case 2: // Functional
+                this.filterdCourses = this.functionalFilter(allAvailableCourses);
+                this.competencyMatchedByCategory = this.functionalCompetencyFilter(this.planData.competencies);
+                break;
+            case 3: // Domain
+                this.filterdCourses = this.domainFilter(allAvailableCourses);
+                this.competencyMatchedByCategory = this.domainCompetencyFilter(this.planData.competencies);
+                break;
+        }
+        console.log('this.filterdCourses', this.filterdCourses);
+        console.log('this.competencyMatchedByCategory', this.competencyMatchedByCategory);
+    }
+    getAllAvailableCourses() {
+        // Start with original data (AI recommended courses)
+        const allCourses = [...this.originalData];
+        const seenIdentifiers = new Set();
+        // Track original course identifiers
+        this.originalData.forEach(course => {
+            if (course.identifier)
+                seenIdentifiers.add(course.identifier);
+            if (course.id)
+                seenIdentifiers.add(course.id);
+        });
+        // Add suggested courses (iGOT platform courses)
+        this.suggestedCourses.forEach(course => {
+            const courseId = course.identifier || course.id;
+            if (courseId && !seenIdentifiers.has(courseId)) {
+                allCourses.push(course);
+                seenIdentifiers.add(courseId);
+            }
+        });
+        // Add user-added courses
+        this.userAddedCourses.forEach(course => {
+            const courseId = course.identifier || course.id;
+            if (courseId && !seenIdentifiers.has(courseId)) {
+                // Ensure user-added courses have proper structure
+                if (!course.course_type) {
+                    course.course_type = 'User Added';
+                }
+                if (!course.identifier && course.id) {
+                    course.identifier = course.id;
+                }
+                allCourses.push(course);
+                seenIdentifiers.add(courseId);
+            }
+        });
+        console.log('getAllAvailableCourses breakdown:', {
+            originalData: this.originalData.length,
+            suggestedCourses: this.suggestedCourses.length,
+            userAddedCourses: this.userAddedCourses.length,
+            totalAvailable: allCourses.length
+        });
+        console.log('allCourses--', allCourses);
+        allCourses.forEach((item) => {
+            if (item && item.organisation && item.organisation.length) {
+                if (this.filteredProviders.indexOf(item.organisation[0]) < 0) {
+                    this.filteredProviders.push(item.organisation[0]);
+                }
+            }
+        });
+        this.fullCourseList = allCourses;
+        let identifiersArr = [];
+        this.fullCourseList.map((item) => {
+            identifiersArr.push(item?.identifier);
+        });
+        this.sharedService.getAdditionalParameterforSuggestedCourses(identifiersArr).subscribe((response) => {
+            if (response && response.result && response.result.content && response.result.content.length) {
+                for (let i = 0; i < response.result.content.length; i++) {
+                    for (let j = 0; j < this.fullCourseList.length; j++) {
+                        if (this.fullCourseList[j]['identifier'] === response.result.content[i]['identifier']) {
+                            this.fullCourseList[j]['language'] = response.result.content[i]['language'];
+                            this.fullCourseList[j]['avgRating'] = response.result.content[i]['avgRating'];
+                            this.fullCourseList[j]['course'] = response.result.content[i]['name'];
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+        return allCourses;
+    }
+    /**
+     * Rebuild filterdCourses array with all available course types
+     * This ensures consistency across the application
+     */
+    rebuildFilteredCourses() {
+        this.filterdCourses = this.getAllAvailableCourses();
+        console.log('Rebuilt filterdCourses with all course types:', {
+            total: this.filterdCourses.length,
+            breakdown: {
+                original: this.originalData.length,
+                suggested: this.suggestedCourses.length,
+                userAdded: this.userAddedCourses.length
+            }
+        });
+    }
+    behavioralFilter(data) {
+        return data.filter(item => {
+            if (!item)
+                return false;
+            // Handle different competency property names
+            let competencies = [];
+            if (item.competencies && Array.isArray(item.competencies)) {
+                competencies = item.competencies;
+            }
+            else if (item.competencies_v6 && Array.isArray(item.competencies_v6)) {
+                competencies = item.competencies_v6;
+            }
+            return competencies.some(c => c && ((c?.competencyAreaName?.toLowerCase() === 'behavioral') || c?.competencyAreaName?.toLowerCase() === 'behavioural'));
+        });
+    }
+    behavioralCompetencyFilter(data) {
+        console.log('data--', data);
+        const behavioralThemes = data
+            .filter(item => item?.type &&
+            ['behavioral', 'behavioural'].includes(item.type.toLowerCase()))
+            .map(item => `${item.theme}-${item.sub_theme}`)
+            .filter((theme) => Boolean(theme)); // Ensures type safety
+        const uniqueBehavioralThemes = Array.from(new Set(behavioralThemes));
+        console.log(uniqueBehavioralThemes);
+        return uniqueBehavioralThemes;
+    }
+    functionalCompetencyFilter(data) {
+        const functionalThemes = data
+            .filter(item => item?.type &&
+            ['functional'].includes(item.type.toLowerCase()))
+            .map(item => `${item.theme}-${item.sub_theme}`)
+            .filter((theme) => Boolean(theme)); // Ensures type safety
+        const uniqueFunctionalThemes = Array.from(new Set(functionalThemes));
+        console.log(uniqueFunctionalThemes);
+        return uniqueFunctionalThemes;
+        // console.log(uniqueCompetencyAreaNames);
+    }
+    domainCompetencyFilter(data) {
+        const domainThemes = data
+            .filter(item => item?.type &&
+            ['domain'].includes(item.type.toLowerCase()))
+            .map(item => `${item.theme}-${item.sub_theme}`)
+            .filter((theme) => Boolean(theme)); // Ensures type safety
+        const uniqueDomainThemes = Array.from(new Set(domainThemes));
+        console.log(uniqueDomainThemes);
+        return uniqueDomainThemes;
+        // console.log(uniqueCompetencyAreaNames);
+    }
+    functionalFilter(data) {
+        return data.filter(item => {
+            if (!item)
+                return false;
+            // Handle different competency property names
+            let competencies = [];
+            if (item.competencies && Array.isArray(item.competencies)) {
+                competencies = item.competencies;
+            }
+            else if (item.competencies_v6 && Array.isArray(item.competencies_v6)) {
+                competencies = item.competencies_v6;
+            }
+            return competencies.some(c => c && c?.competencyAreaName?.toLowerCase() === 'functional');
+        });
+    }
+    domainFilter(data) {
+        return data.filter(item => {
+            if (!item)
+                return false;
+            // Handle different competency property names
+            let competencies = [];
+            if (item.competencies && Array.isArray(item.competencies)) {
+                competencies = item.competencies;
+            }
+            else if (item.competencies_v6 && Array.isArray(item.competencies_v6)) {
+                competencies = item.competencies_v6;
+            }
+            return competencies.some(c => c && c?.competencyAreaName?.toLowerCase() === 'domain');
+        });
+    }
+    gapAnalysisStats() {
+        console.log('this.planData', this.planData);
+        // Always use ALL competencies for calculating overall stats
+        const allCompetencies = this.planData.competencies;
+        // Filter for category-specific calculations
+        let categorySpecificCompetencies = this.planData.competencies;
+        if (this.selectedCategory === 'all') {
+            categorySpecificCompetencies = this.planData.competencies;
+        }
+        else if (this.selectedCategory === 'behavioral') {
+            categorySpecificCompetencies = this.planData.competencies.filter(item => item.type?.toLowerCase() === this.selectedCategory);
+        }
+        else if (this.selectedCategory === 'functional') {
+            categorySpecificCompetencies = this.planData.competencies.filter(item => item.type?.toLowerCase() === this.selectedCategory);
+        }
+        else if (this.selectedCategory === 'domain') {
+            categorySpecificCompetencies = this.planData.competencies.filter(item => item.type?.toLowerCase() === this.selectedCategory);
+        }
+        // Count ALL competencies by category (not just filtered ones)
+        const masterListByCategory = { total: allCompetencies.length, behavioural: 0, functional: 0, domain: 0 };
+        // IMPORTANT: Use all available courses for consistent coverage calculation
+        // This should match what's available in the Filter By Competency section
+        const allCourseCompetencies = [];
+        const allAvailableCoursesForStats = this.getAllAvailableCourses();
+        allAvailableCoursesForStats.forEach(course => {
+            // Handle different competency property names
+            let competencies = [];
+            if (course && course.competencies && Array.isArray(course.competencies)) {
+                competencies = course.competencies;
+            }
+            else if (course && course.competencies_v6 && Array.isArray(course.competencies_v6)) {
+                competencies = course.competencies_v6;
+            }
+            competencies.forEach((list) => {
+                allCourseCompetencies.push(list);
+            });
+        });
+        console.log('allCompetencies', allCompetencies);
+        console.log('categorySpecificCompetencies', categorySpecificCompetencies);
+        console.log('allCourseCompetencies', allCourseCompetencies);
+        // Count all competencies by type for proper totals
+        for (let i = 0; i < allCompetencies.length; i++) {
+            const competencyType = allCompetencies[i]['type']?.toLowerCase();
+            console.log(`Competency ${i}: type="${competencyType}", data:`, allCompetencies[i]);
+            if (competencyType === 'behavioural' || competencyType === 'behavioral') {
+                masterListByCategory['behavioural'] = masterListByCategory['behavioural'] + 1;
+            }
+            if (competencyType === 'functional') {
+                masterListByCategory['functional'] = masterListByCategory['functional'] + 1;
+            }
+            if (competencyType === 'domain') {
+                masterListByCategory['domain'] = masterListByCategory['domain'] + 1;
+            }
+        }
+        console.log('masterListByCategory after counting:', masterListByCategory);
+        // Get matching results for ALL competencies (for overall coverage)
+        const overallResult = this.getMatchedCompetencyStats(allCompetencies, allCourseCompetencies);
+        // Get matching results for category-specific competencies (for filtered view)
+        const categoryResult = this.getMatchedCompetencyStats(categorySpecificCompetencies, allCourseCompetencies);
+        // Set competencyCoveredCount based on selected category (for the filtered numbers)
+        if (this.selectedCategory === 'all') {
+            this.competencyCoveredCount = overallResult['total'];
+        }
+        else if (this.selectedCategory === 'behavioral') {
+            this.competencyCoveredCount = categoryResult['behavioral'] || 0;
+        }
+        else if (this.selectedCategory === 'functional') {
+            this.competencyCoveredCount = categoryResult['functional'] || 0;
+        }
+        else if (this.selectedCategory === 'domain') {
+            this.competencyCoveredCount = categoryResult['domain'] || 0;
+        }
+        // IMPORTANT: Overall Coverage should ALWAYS be based on ALL competencies, not filtered
+        let totalCompetencies = this.planData.competencies.length; // Always use total count
+        let overallCoveredCount = overallResult['total']; // Always use overall results
+        let mathRound = Math.round((overallCoveredCount / totalCompetencies) * 100);
+        this.overallCoverage = `${mathRound}%`;
+        console.log('Overall Coverage Calculation:', {
+            totalCompetencies: totalCompetencies,
+            overallCoveredCount: overallCoveredCount,
+            overallCoverage: this.overallCoverage,
+            selectedCategory: this.selectedCategory,
+            competencyCoveredCount: this.competencyCoveredCount
+        });
+        // Always calculate all category-specific metrics regardless of selected category
+        // This ensures the data is available when switching between categories
+        // Use overallResult for consistent calculations across all categories
+        this.behavioralCompetencyCoveredCount = overallResult['behavioral'] || 0;
+        this.behavioralTotalCompetencies = masterListByCategory['behavioural'];
+        let behavioralMathRound = this.behavioralTotalCompetencies > 0 ? Math.round((this.behavioralCompetencyCoveredCount / this.behavioralTotalCompetencies) * 100) : 0;
+        this.behavioralCoverage = `${behavioralMathRound}%`;
+        this.functionalCompetencyCoveredCount = overallResult['functional'] || 0;
+        this.functionalTotalCompetencies = masterListByCategory['functional'];
+        let functionalMathRound = this.functionalTotalCompetencies > 0 ? Math.round((this.functionalCompetencyCoveredCount / this.functionalTotalCompetencies) * 100) : 0;
+        this.functionalCoverage = `${functionalMathRound}%`;
+        this.domainCompetencyCoveredCount = overallResult['domain'] || 0;
+        this.domainTotalCompetencies = masterListByCategory['domain'];
+        let domainMathRound = this.domainTotalCompetencies > 0 ? Math.round((this.domainCompetencyCoveredCount / this.domainTotalCompetencies) * 100) : 0;
+        this.domainCoverage = `${domainMathRound}%`;
+        console.log('All category metrics calculated:', {
+            behavioral: { covered: this.behavioralCompetencyCoveredCount, total: this.behavioralTotalCompetencies, coverage: this.behavioralCoverage },
+            functional: { covered: this.functionalCompetencyCoveredCount, total: this.functionalTotalCompetencies, coverage: this.functionalCoverage },
+            domain: { covered: this.domainCompetencyCoveredCount, total: this.domainTotalCompetencies, coverage: this.domainCoverage },
+            overall: { covered: overallCoveredCount, total: totalCompetencies, coverage: this.overallCoverage },
+            selectedCategory: this.selectedCategory,
+            competencyCoveredCountForCategory: this.competencyCoveredCount
+        });
+        console.log('Overall Result:', overallResult);
+        console.log('Category Result:', categoryResult);
+        console.log('this.competencyNotMatchedByCategory', this.competencyNotMatchedByCategory);
+        this.behaviouralNotMatched = this.getCompetencyByCategoryNotMatching('behavioral');
+        this.functionalNotMatched = this.getCompetencyByCategoryNotMatching('functional');
+        this.domainNotMatched = this.getCompetencyByCategoryNotMatching('domain');
+        this.getBehaviouralMatched();
+        this.getFunctionalMatched();
+        this.getDomainMatched();
+    }
+    getMatchedCompetencyStats(primaryArray, secondaryArray) {
+        // Convert both arrays to ensure consistent casing
+        const counts = {
+            behavioral: 0,
+            functional: 0,
+            domain: 0,
+            total: 0
+        };
+        // Clear the competencyNotMatchedByCategory array for fresh calculation
+        this.competencyNotMatchedByCategory = [];
+        // Set to keep track of unique matches
+        const seen = new Set();
+        const matchedCompetencies = new Set();
+        for (const primary of primaryArray) {
+            const typeKey = primary.type?.toLowerCase().trim();
+            const themeKey = primary.theme?.toLowerCase().trim();
+            const subThemeKey = primary.sub_theme?.toLowerCase().trim();
+            let isMatched = false;
+            for (const secondary of secondaryArray) {
+                // Normalize secondary keys
+                let secType = secondary?.competencyAreaName?.toLowerCase().trim();
+                let secTheme = secondary?.competencyThemeName?.toLowerCase().trim();
+                let secSubTheme = secondary?.competencySubThemeName?.toLowerCase().trim();
+                // Fix for data inconsistency
+                if (secType === 'behavioural')
+                    secType = 'behavioral';
+                // Create unique match key for primary competency
+                const matchKey = `${typeKey}|${themeKey}|${subThemeKey}`;
+                // Enhanced cross-matching logic as requested:
+                // 1. Role mapping Theme vs Course Theme
+                // 2. Role mapping Sub Theme vs Course Sub Theme  
+                // 3. Role mapping Theme vs Course Sub Theme
+                // 4. Role mapping Sub Theme vs Course Theme
+                const themeToThemeMatch = themeKey === secTheme;
+                const subThemeToSubThemeMatch = subThemeKey === secSubTheme;
+                const themeToSubThemeMatch = themeKey === secSubTheme;
+                const subThemeToThemeMatch = subThemeKey === secTheme;
+                let matchType = '';
+                let isMatch = false;
+                if (typeKey === secType && !seen.has(matchKey)) {
+                    if (themeToThemeMatch) {
+                        matchType = 'Theme-to-Theme';
+                        isMatch = true;
+                    }
+                    else if (subThemeToSubThemeMatch) {
+                        matchType = 'SubTheme-to-SubTheme';
+                        isMatch = true;
+                    }
+                    else if (themeToSubThemeMatch) {
+                        matchType = 'Theme-to-SubTheme';
+                        isMatch = true;
+                    }
+                    else if (subThemeToThemeMatch) {
+                        matchType = 'SubTheme-to-Theme';
+                        isMatch = true;
+                    }
+                }
+                if (isMatch) {
+                    console.log(`✅ MATCH FOUND [${matchType}]:`, {
+                        roleMapping: { type: typeKey, theme: themeKey, subTheme: subThemeKey },
+                        course: { type: secType, theme: secTheme, subTheme: secSubTheme },
+                        matchType: matchType
+                    });
+                    // Store matched competency info for later use
+                    let obj = {};
+                    obj[typeKey] = [themeKey]; // Store the original theme, not the course theme
+                    this.competencyNotMatchedByCategory.push(obj);
+                    seen.add(matchKey);
+                    matchedCompetencies.add(themeKey); // Track matched themes
+                    isMatched = true;
+                    if (counts.hasOwnProperty(typeKey)) {
+                        counts[typeKey]++;
+                    }
+                    else {
+                        counts[typeKey] = 1;
+                    }
+                    counts.total++;
+                    break; // Stop looking for matches for this primary competency
+                }
+            }
+        }
+        return counts;
+    }
+    getCompetencyByCategoryNotMatching(categoryType) {
+        // Get all competencies for the given category from role mapping
+        let allCategoryCompetencies = [];
+        for (let i = 0; i < this.planData.competencies.length; i++) {
+            if (this.planData.competencies[i]['type']?.toLowerCase() === categoryType?.toLowerCase()) {
+                allCategoryCompetencies.push(this.planData.competencies[i]['theme']?.toLowerCase().trim());
+            }
+        }
+        // Get matched competencies for this category from courses
+        let matchedCompetencies = [];
+        for (let i = 0; i < this.competencyNotMatchedByCategory.length; i++) {
+            if (this.competencyNotMatchedByCategory[i][categoryType?.toLowerCase()]) {
+                // Extract matched themes from course competencies
+                this.competencyNotMatchedByCategory[i][categoryType?.toLowerCase()].forEach(theme => {
+                    if (theme) {
+                        matchedCompetencies.push(theme.toLowerCase().trim());
+                    }
+                });
+            }
+        }
+        // Enhanced matching: check both theme and subtheme from courses against FRAC competencies
+        // IMPORTANT: Use all available courses for consistent coverage calculation
+        const allCoursesForMatching = this.getAllAvailableCourses();
+        allCoursesForMatching.forEach(course => {
+            // Handle different competency property names
+            let competencies = [];
+            if (course && course.competencies && Array.isArray(course.competencies)) {
+                competencies = course.competencies;
+            }
+            else if (course && course.competencies_v6 && Array.isArray(course.competencies_v6)) {
+                competencies = course.competencies_v6;
+            }
+            competencies.forEach((comp) => {
+                let secType = comp?.competencyAreaName?.toLowerCase().trim();
+                if (secType === 'behavioural')
+                    secType = 'behavioral';
+                if (secType === categoryType?.toLowerCase()) {
+                    const courseTheme = comp.competencyThemeName?.toLowerCase().trim();
+                    const courseSubTheme = comp.competencySubThemeName?.toLowerCase().trim();
+                    // Check if any FRAC competency matches this course competency
+                    for (let i = 0; i < this.planData.competencies.length; i++) {
+                        const fracComp = this.planData.competencies[i];
+                        if (fracComp['type']?.toLowerCase() === categoryType?.toLowerCase()) {
+                            const fracTheme = fracComp['theme']?.toLowerCase().trim();
+                            const fracSubTheme = fracComp['sub_theme']?.toLowerCase().trim();
+                            // Enhanced cross-matching logic (same as in getMatchedCompetencyStats):
+                            // 1. Course Theme vs FRAC Theme
+                            // 2. Course Sub Theme vs FRAC Sub Theme  
+                            // 3. Course Theme vs FRAC Sub Theme
+                            // 4. Course Sub Theme vs FRAC Theme
+                            const courseThemeToFracTheme = courseTheme === fracTheme;
+                            const courseSubThemeToFracSubTheme = courseSubTheme === fracSubTheme;
+                            const courseThemeToFracSubTheme = courseTheme === fracSubTheme;
+                            const courseSubThemeToFracTheme = courseSubTheme === fracTheme;
+                            if (courseThemeToFracTheme || courseSubThemeToFracSubTheme ||
+                                courseThemeToFracSubTheme || courseSubThemeToFracTheme) {
+                                let matchType = '';
+                                if (courseThemeToFracTheme)
+                                    matchType = 'CourseTheme-to-FRACTheme';
+                                else if (courseSubThemeToFracSubTheme)
+                                    matchType = 'CourseSubTheme-to-FRACSubTheme';
+                                else if (courseThemeToFracSubTheme)
+                                    matchType = 'CourseTheme-to-FRACSubTheme';
+                                else if (courseSubThemeToFracTheme)
+                                    matchType = 'CourseSubTheme-to-FRACTheme';
+                                console.log(`✅ COMPETENCY MATCH FOUND [${matchType}] for ${categoryType}:`, {
+                                    course: { theme: courseTheme, subTheme: courseSubTheme },
+                                    frac: { theme: fracTheme, subTheme: fracSubTheme },
+                                    matchType: matchType
+                                });
+                                matchedCompetencies.push(fracTheme);
+                                break; // Found a match, move to next course competency
+                            }
+                        }
+                    }
+                }
+            });
+        });
+        // Remove duplicates from matched competencies
+        matchedCompetencies = [...new Set(matchedCompetencies)];
+        console.log(`\n=== ${categoryType.toUpperCase()} COMPETENCY MATCHING ===`);
+        console.log(`${categoryType} - All FRAC competencies:`, allCategoryCompetencies);
+        console.log(`${categoryType} - Matched from courses:`, matchedCompetencies);
+        console.log(`${categoryType} - Match rate: ${matchedCompetencies.length}/${allCategoryCompetencies.length} (${Math.round((matchedCompetencies.length / allCategoryCompetencies.length) * 100)}%)`);
+        // Return unmatched competencies (those in role mapping but not covered by courses)
+        return this.compareStringArrays(allCategoryCompetencies, matchedCompetencies);
+    }
+    compareStringArrays(arr1, arr2) {
+        console.log('All competencies in category:', arr1);
+        console.log('Matched competencies from courses:', arr2);
+        // Return items in arr1 that are NOT in arr2 (unmatched competencies)
+        const unmatched = arr1.filter(item => !arr2.includes(item));
+        console.log('Unmatched competencies:', unmatched);
+        return unmatched;
+    }
+    addCourse(missingCompetency, competencyType) {
+        let dialogData = { ...this.planData };
+        // If competency parameters are provided, add them to the dialog data
+        if (missingCompetency && competencyType) {
+            // Parse the theme from the missing competency string (assumes format "theme-subtheme" or just "theme")
+            const theme = missingCompetency.trim();
+            dialogData.prefillCompetency = {
+                type: competencyType,
+                theme: theme
+            };
+        }
+        const dialogRef = this.dialog.open(AddCourseComponent, {
+            width: '1000px',
+            data: dialogData,
+            panelClass: 'view-cbp-plan-popup',
+            minHeight: '400px',
+            maxHeight: '90vh',
+            disableClose: true // Optional: prevent closing with outside click
+        });
+        dialogRef.afterClosed().subscribe(result => {
+            if (result === 'saved') {
+                console.log('Course added successfully! Refreshing data...');
+                // Refresh user courses to include the newly added course
+                this.getUserCourse();
+                // Refresh gap analysis with the latest data
+                setTimeout(() => {
+                    this.updateGapAnalysisAfterCoursesUpdate();
+                    console.log('Gap analysis refreshed after course addition');
+                }, 500); // Small delay to ensure data is loaded
+            }
+        });
+    }
+    filterOnCompetencyTheme(themeItem) {
+        this.selectedThemeFilter = themeItem;
+        let themeName = themeItem?.split("-")[0]?.trim();
+        let subThemeName = themeItem?.split("-")[1]?.trim();
+        console.log('Filtering by theme:', themeName, 'subTheme:', subThemeName, 'Tab index:', this.innerTabActiveIndex);
+        // Get the current competency type based on the active tab
+        let competencyType = '';
+        if (this.innerTabActiveIndex === 1) {
+            competencyType = 'behavioral';
+        }
+        else if (this.innerTabActiveIndex === 2) {
+            competencyType = 'functional';
+        }
+        else if (this.innerTabActiveIndex === 3) {
+            competencyType = 'domain';
+        }
+        // Get all available courses using the helper method
+        const allAvailableCourses = this.getAllAvailableCourses();
+        console.log('Total courses to filter from:', allAvailableCourses.length);
+        this.filterdCourses = allAvailableCourses.filter(course => {
+            if (!course)
+                return false;
+            // Handle different competency property names
+            let competencies = [];
+            if (course.competencies && Array.isArray(course.competencies)) {
+                competencies = course.competencies;
+            }
+            else if (course.competencies_v6 && Array.isArray(course.competencies_v6)) {
+                competencies = course.competencies_v6;
+            }
+            if (competencies.length === 0)
+                return false;
+            // Filter by competency type and theme/subtheme
+            return competencies.some(comp => {
+                if (!comp)
+                    return false;
+                // Check competency type matches current tab
+                let compType = comp?.competencyAreaName?.toLowerCase();
+                if (compType === 'behavioural')
+                    compType = 'behavioral'; // Normalize spelling
+                if (compType !== competencyType)
+                    return false;
+                // Check cross-matching like gap analysis: theme vs subtheme and subtheme vs theme
+                const compTheme = comp?.competencyThemeName?.toLowerCase()?.trim();
+                const compSubTheme = comp?.competencySubThemeName?.toLowerCase()?.trim();
+                const searchTheme = themeName?.toLowerCase();
+                const searchSubTheme = subThemeName?.toLowerCase();
+                // Enhanced cross-matching logic like gap analysis:
+                // 1. Selected Theme vs Course Theme
+                // 2. Selected Sub Theme vs Course Sub Theme  
+                // 3. Selected Theme vs Course Sub Theme
+                // 4. Selected Sub Theme vs Course Theme
+                const themeToThemeMatch = searchTheme && compTheme === searchTheme;
+                const subThemeToSubThemeMatch = searchSubTheme && compSubTheme === searchSubTheme;
+                const themeToSubThemeMatch = searchTheme && compSubTheme === searchTheme;
+                const subThemeToThemeMatch = searchSubTheme && compTheme === searchSubTheme;
+                const isMatch = themeToThemeMatch || subThemeToSubThemeMatch || themeToSubThemeMatch || subThemeToThemeMatch;
+                // Log matches for debugging (similar to gap analysis)
+                if (isMatch) {
+                    let matchType = '';
+                    if (themeToThemeMatch)
+                        matchType = 'Theme-to-Theme';
+                    else if (subThemeToSubThemeMatch)
+                        matchType = 'SubTheme-to-SubTheme';
+                    else if (themeToSubThemeMatch)
+                        matchType = 'Theme-to-SubTheme';
+                    else if (subThemeToThemeMatch)
+                        matchType = 'SubTheme-to-Theme';
+                    console.log(`✅ FILTER MATCH FOUND [${matchType}]:`, {
+                        selected: { theme: searchTheme, subTheme: searchSubTheme },
+                        course: { type: compType, theme: compTheme, subTheme: compSubTheme },
+                        matchType: matchType
+                    });
+                }
+                // Match if any of the cross-matching conditions are met
+                return isMatch;
+            });
+        });
+        console.log('Filtered courses for theme:', themeName, 'Count:', this.filterdCourses.length);
+        console.log('Filtered courses:', this.filterdCourses.map(c => c.name || c.course));
+    }
+    clearThemeFilter() {
+        this.selectedThemeFilter = '';
+        // Reset to category filtered courses by calling the tab change method
+        this.onInnerTabChange({
+            index: this.innerTabActiveIndex,
+            tab: { textLabel: this.innerTabActiveText }
+        });
+        console.log('Theme filter cleared, showing all courses for category:', this.innerTabActiveText);
+    }
+    isThemeSelected(theme) {
+        return this.selectedThemeFilter === theme;
+    }
+    /**
+     * Add course for the currently selected theme filter with prefilled competency data
+     */
+    addCourseForSelectedTheme() {
+        if (!this.selectedThemeFilter) {
+            console.warn('No theme selected for adding course');
+            return;
+        }
+        // Parse theme and sub-theme from selectedThemeFilter (format: "Theme - SubTheme")
+        const themeParts = this.selectedThemeFilter.split('-');
+        const theme = themeParts[0]?.trim();
+        const subTheme = themeParts[1]?.trim();
+        // Get the current competency type based on the active tab
+        // Map the tab labels to the format expected by AddCourseComponent
+        let competencyType = '';
+        if (this.innerTabActiveIndex === 1) {
+            competencyType = 'Behavioral'; // Tab label is "behavioural"
+        }
+        else if (this.innerTabActiveIndex === 2) {
+            competencyType = 'Functional'; // Tab label is "functional"
+        }
+        else if (this.innerTabActiveIndex === 3) {
+            competencyType = 'Domain'; // Tab label is "domain"
+        }
+        console.log('Tab mapping - innerTabActiveIndex:', this.innerTabActiveIndex, 'innerTabActiveText:', this.innerTabActiveText, 'mapped competencyType:', competencyType);
+        console.log('Adding course for missing competency:', {
+            competencyType,
+            theme,
+            subTheme,
+            selectedThemeFilter: this.selectedThemeFilter
+        });
+        // Create dialog data with prefilled competency information
+        let dialogData = { ...this.planData };
+        dialogData.prefillCompetency = {
+            type: competencyType,
+            theme: theme,
+            subTheme: subTheme || '' // Include sub-theme if available
+        };
+        const dialogRef = this.dialog.open(AddCourseComponent, {
+            width: '800px',
+            data: dialogData,
+            panelClass: 'view-cbp-plan-popup',
+            minHeight: '400px',
+            maxHeight: '90vh',
+            disableClose: true
+        });
+        dialogRef.afterClosed().subscribe(result => {
+            if (result === 'saved') {
+                console.log('Course added successfully for competency! Refreshing data...');
+                // Refresh user courses to include the newly added course
+                this.getUserCourse();
+                // Update gap analysis after course addition
+                this.updateGapAnalysisAfterCoursesUpdate();
+            }
+        });
+    }
+    getDuration(time) {
+        return this.sharedService.convert(time);
+    }
+    getBehaviouralMatched() {
+        this.behaviouralMatched = [];
+        console.log('this.planData.competencies', this.planData);
+        console.log('this.behaviouralNotMatched', this.behaviouralNotMatched);
+        this.planData.competencies.map((item) => {
+            if (item && item?.type === 'Behavioral' && this.behaviouralNotMatched.indexOf(item?.theme?.toLowerCase()) < 0) {
+                this.behaviouralMatched.push(item);
+            }
+        });
+        console.log('this.behaviouralMatched--', this.behaviouralMatched);
+    }
+    getFunctionalMatched() {
+        this.functionalMatched = [];
+        this.planData.competencies.map((item) => {
+            if (item && item?.type === 'Functional' && this.functionalNotMatched.indexOf(item?.theme?.toLowerCase()) < 0) {
+                this.functionalMatched.push(item);
+            }
+        });
+        return this.functionalMatched;
+    }
+    getDomainMatched() {
+        this.domainMatched = [];
+        this.planData.competencies.map((item) => {
+            if (item && item?.type === 'Domain' && this.domainNotMatched.indexOf(item?.theme?.toLowerCase()) < 0) {
+                this.domainMatched.push(item);
+            }
+        });
+        console.log('this.domainMatched--', this.domainMatched);
+    }
+    downloadPDF() {
+        this.isPDFDownload = true;
+        this.loading = true;
+        const element = this.pdfContent.nativeElement;
+        // Wait for images to load
+        const images = element.querySelectorAll('img');
+        const promises = Array.from(images).map((img) => {
+            if (img.complete)
+                return Promise.resolve();
+            return new Promise(resolve => img.onload = resolve);
+        });
+        Promise.all(promises).then(() => {
+            const options = {
+                margin: 0.20,
+                filename: 'Gap Analysis.pdf',
+                image: { type: 'jpeg', quality: 0.98 },
+                html2canvas: {
+                    scale: 2,
+                    useCORS: true,
+                    scrollY: 0,
+                },
+                jsPDF: {
+                    unit: 'in',
+                    format: 'a4',
+                    orientation: 'portrait'
+                },
+                pagebreak: {
+                    mode: ['css', 'legacy'],
+                    before: '.page-break',
+                    avoid: ['.no-break']
+                }
+            };
+            html2pdf().from(element).set(options).save();
+            setTimeout(() => {
+                this.isPDFDownload = false;
+                this.loading = false;
+            }, 3000);
+        });
+    }
+    redirectToToc(item) {
+        if (item?.public_link) {
+            window.open(item?.public_link, '_blank');
+        }
+        else {
+            let url = `https://portal.igotkarmayogi.gov.in/app/toc/${item?.identifier}/overview?`;
+            window.open(url, '_blank');
+        }
+    }
+    /**
+     * Initialize gap analysis stats after initial data load
+     */
+    initializeGapAnalysisStats() {
+        // Set a small timeout to ensure all async operations complete
+        setTimeout(() => {
+            if (this.filterdCourses && this.filterdCourses.length > 0) {
+                this.gapAnalysisStats();
+            }
+        }, 100);
+    }
+    /**
+     * Update gap analysis stats after courses are updated (like suggested courses added)
+     */
+    updateGapAnalysisAfterCoursesUpdate() {
+        // Don't modify originalData - it should remain as AI recommended courses only
+        // The gap analysis already properly includes all course types
+        // Recalculate gap analysis stats
+        this.gapAnalysisStats();
+    }
+    /**
+     * Regenerate course recommendations by deleting existing recommendations and generating new ones
+     */
+    async regenerateCourseRecommendations() {
+        if (this.isRegenerating) {
+            return; // Prevent multiple simultaneous regenerations
+        }
+        try {
+            this.isRegenerating = true;
+            // Show confirmation dialog
+            const confirmed = await this.showConfirmationDialog();
+            if (!confirmed) {
+                this.isRegenerating = false;
+                return;
+            }
+            console.log('Starting course recommendation regeneration...');
+            // Set regeneration progress state
+            this.isRegeneratingWithProgress = true;
+            this.dataLoaded = false; // Hide main content during regeneration
+            // Step 1: Delete existing course recommendations
+            await this.deleteCourseRecommendations();
+            // Step 2: Generate new course recommendations
+            await this.generateNewCourseRecommendations();
+            // Step 3: Refresh the current data
+            this.refreshComponent();
+            console.log('Course recommendation regeneration completed successfully');
+            // Show success message
+            this.snackBar.open('Course recommendations regenerated successfully!', 'Close', {
+                duration: 5000,
+                panelClass: ['success-snackbar']
+            });
+        }
+        catch (error) {
+            console.error('Error during course recommendation regeneration:', error);
+            // Show error message
+            this.snackBar.open('Failed to regenerate course recommendations. Please try again.', 'Close', {
+                duration: 5000,
+                panelClass: ['error-snackbar']
+            });
+        }
+        finally {
+            this.isRegenerating = false;
+            this.isRegeneratingWithProgress = false;
+            this.dataLoaded = true; // Ensure main content is shown after regeneration
+        }
+    }
+    /**
+     * Show confirmation dialog for regenerate action
+     */
+    showConfirmationDialog() {
+        return new Promise((resolve) => {
+            // Create a custom confirmation dialog
+            const dialogRef = this.dialog.open(RegenerateConfirmationDialog, {
+                width: '450px',
+                panelClass: 'regenerate-confirmation-dialog',
+                disableClose: true
+            });
+            dialogRef.afterClosed().subscribe(result => {
+                resolve(result === true);
+            });
+        });
+    }
+    /**
+     * Delete existing course recommendations for the current role mapping
+     */
+    deleteCourseRecommendations() {
+        return new Promise((resolve, reject) => {
+            const roleMapId = this.planData?.id;
+            if (!roleMapId) {
+                reject(new Error('Role mapping ID not found'));
+                return;
+            }
+            console.log('Deleting course recommendations for role mapping:', roleMapId);
+            this.sharedService.deleteCourseRecommendations(roleMapId).subscribe({
+                next: (response) => {
+                    console.log('Course recommendations deleted successfully:', response);
+                    resolve(response);
+                },
+                error: (error) => {
+                    console.error('Error deleting course recommendations:', error);
+                    reject(error);
+                }
+            });
+        });
+    }
+    /**
+     * Generate new course recommendations during regeneration
+     */
+    generateNewCourseRecommendations() {
+        console.log('Generating new course recommendations...');
+        return this.getRecommendedCourseForRegeneration(this.planData.id);
+    }
+    /**
+     * Enhanced course generation specifically for regeneration with progressive loading
+     */
+    getRecommendedCourseForRegeneration(role_mapping_id) {
+        return new Promise((resolve, reject) => {
+            // Start the progressive loading simulation for regeneration
+            this.startRegenerativeProgressiveLoading();
+            // Make the actual API call
+            // this.sharedService.getRecommendedCourse(role_mapping_id).subscribe({
+            //   next: (response) => {
+            //     // Stop progressive loading and show completion
+            //     this.isRegeneratingWithProgress = false; // This will stop the interval
+            //     this.progressPercentage = 100;
+            //     this.currentProcessingStage = 'Course recommendations regenerated successfully!';
+            //     // Clear the loading state after showing completion
+            //     setTimeout(() => {
+            //       this.currentProcessingStage = '';
+            //       this.progressPercentage = 0;
+            //       resolve(response);
+            //     }, 2000);
+            //   },
+            //   error: (error) => {
+            //     // Stop progressive loading
+            //     this.isRegeneratingWithProgress = false;
+            //     this.currentProcessingStage = '';
+            //     this.progressPercentage = 0;
+            //     // Handle specific error cases
+            //     if (error.status === 409 || error.error?.detail?.includes('already exists')) {
+            //       // Course recommendations already exist - this is normal
+            //       console.log('Course recommendations already exist, loading existing data...');
+            //       this.currentProcessingStage = 'Loading existing course recommendations...';
+            //       // Try to get existing data
+            //       this.sharedService.getRecommendedCourse(role_mapping_id).subscribe({
+            //         next: (existingResponse) => {
+            //           console.log('Successfully loaded existing course recommendations');
+            //           this.progressPercentage = 100;
+            //           this.currentProcessingStage = 'Loaded existing course recommendations successfully!';
+            //           setTimeout(() => {
+            //             this.currentProcessingStage = '';
+            //             this.progressPercentage = 0;
+            //             resolve(existingResponse);
+            //           }, 2000);
+            //         },
+            //         error: (loadError) => {
+            //           console.error('Failed to load existing course recommendations:', loadError);
+            //           this.currentProcessingStage = '';
+            //           this.progressPercentage = 0;
+            //           reject(loadError);
+            //         }
+            //       });
+            //     } else {
+            //       console.error('Error during course recommendation regeneration:', error);
+            //       reject(error);
+            //     }
+            //   }
+            // });
+            this.isRegeneratingWithProgress = true;
+            this.progressPercentage = 0;
+            this.currentProcessingStage = 'Generating course recommendations...';
+            interval(5000)
+                .pipe(switchMap(() => this.sharedService.getRecommendedCourse(role_mapping_id).pipe(catchError(error => {
+                // Pass error through observable so polling logic can inspect it
+                return of({ error });
+            }))), tap(res => console.log("Polling result:", res)), 
+            /**
+             * ⬇️ STOP POLLING only when:
+             * - SUCCESS → res.status === COMPLETED
+             * - ERROR → conflict / already exists
+             */
+            takeWhile(res => {
+                if (res?.status === 'COMPLETED')
+                    return false; // Stop
+                if (res?.error?.status === 409)
+                    return false; // Stop
+                if (res?.error?.error?.detail?.includes('already exists'))
+                    return false; // Stop
+                return true; // Keep polling
+            }, true) // include final emission
+            )
+                .subscribe({
+                next: (res) => {
+                    /** -------------------------------
+                     *  SUCCESS CASE (status COMPLETED)
+                     -------------------------------- */
+                    if (res?.status === 'COMPLETED') {
+                        this.isRegeneratingWithProgress = false;
+                        this.progressPercentage = 100;
+                        this.currentProcessingStage = 'Course recommendations regenerated successfully!';
+                        setTimeout(() => {
+                            this.currentProcessingStage = '';
+                            this.progressPercentage = 0;
+                            resolve(res);
+                        }, 2000);
+                        return;
+                    }
+                    /** -----------------------------------
+                     *  ERROR CASE (409 / already exists)
+                     ------------------------------------ */
+                    if (res?.error) {
+                        const error = res.error;
+                        if (error.status === 409 || error?.error?.detail?.includes('already exists')) {
+                            this.currentProcessingStage = 'Loading existing course recommendations...';
+                            this.sharedService.getRecommendedCourse(role_mapping_id).subscribe({
+                                next: (existingData) => {
+                                    this.progressPercentage = 100;
+                                    this.currentProcessingStage = 'Loaded existing course recommendations successfully!';
+                                    setTimeout(() => {
+                                        this.currentProcessingStage = '';
+                                        this.progressPercentage = 0;
+                                        resolve(existingData);
+                                    }, 2000);
+                                },
+                                error: loadError => reject(loadError)
+                            });
+                            return;
+                        }
+                        /** Any other error → stop & reject */
+                        this.isRegeneratingWithProgress = false;
+                        this.currentProcessingStage = '';
+                        this.progressPercentage = 0;
+                        reject(error);
+                        return;
+                    }
+                    /** ------------------------------
+                     *  STILL PROCESSING (keep polling)
+                     ------------------------------- */
+                    this.progressPercentage = Math.min(this.progressPercentage + 10, 95);
+                    this.currentProcessingStage = 'Still processing course recommendations...';
+                },
+                error: err => reject(err)
+            });
+        });
+    }
+    // Progressive loading methods for regeneration
+    startRegenerativeProgressiveLoading() {
+        this.currentProcessingStage = this.processingStages[0];
+        this.progressPercentage = 0;
+        this.stageStartTime = Date.now();
+        this.simulateRegenerativeProgressiveStages();
+    }
+    simulateRegenerativeProgressiveStages() {
+        let currentStageIndex = 0;
+        const totalDuration = 60000; // 60 seconds estimated duration
+        const stageInterval = totalDuration / this.processingStages.length;
+        const progressInterval = setInterval(() => {
+            // Stop if regeneration is complete
+            if (!this.isRegeneratingWithProgress) {
+                clearInterval(progressInterval);
+                return;
+            }
+            const elapsed = Date.now() - this.stageStartTime;
+            const currentStageProgress = (elapsed % stageInterval) / stageInterval;
+            const stageIndex = Math.min(Math.floor(elapsed / stageInterval), this.processingStages.length - 1);
+            // Update stage if needed
+            if (stageIndex !== currentStageIndex && stageIndex < this.processingStages.length) {
+                currentStageIndex = stageIndex;
+                this.currentProcessingStage = this.processingStages[stageIndex];
+            }
+            // Calculate overall progress (each stage is worth ~16.67%)
+            const baseProgress = (stageIndex / this.processingStages.length) * 100;
+            const stageProgress = (currentStageProgress / this.processingStages.length) * 100;
+            this.progressPercentage = Math.min(Math.round(baseProgress + stageProgress), 95);
+        }, 1000);
+    }
+    /**
+     * Refresh the component data after regeneration
+     */
+    refreshComponent() {
+        console.log('Refreshing component data...');
+        // Reset all filters and selections
+        this.selectedThemeFilter = '';
+        this.selectFilterCourses = [];
+        this.filterdCourses = [];
+        this.originalFilteredCourses = [];
+        this.suggestedCourses = [];
+        this.userAddedCourses = [];
+        // Reset tab states
+        this.innerTabActiveIndex = 0;
+        this.outerTabActiveIndex = 0;
+        // Call the data loading methods directly to avoid resetting dataLoaded
+        this.loadComponentData();
+    }
+    /**
+     * Load component data (separated from ngOnInit for reuse)
+     */
+    loadComponentData() {
+        this.getRecommendedCourseWithProgress(this.planData.id).then((res) => {
+            console.log('res', res);
+            this.recommended_course_id = res.id;
+            let allCoures = [];
+            if (res && res.filtered_courses && res.filtered_courses.length) {
+                res?.filtered_courses.forEach((item) => {
+                    if (item?.relevancy >= 85) {
+                        allCoures.push(item);
+                    }
+                });
+                this.originalData = allCoures;
+                this.filterdCourses = allCoures;
+            }
+            console.log('this.filterdCourses', this.filterdCourses);
+            this.getCourses();
+            this.getSuggestedCourse();
+            // Initialize gap analysis stats after courses are loaded
+            this.initializeGapAnalysisStats();
+            this.getUserCourse();
+            // Mark data as loaded after all initial operations
+            this.dataLoaded = true;
+        }).catch((error) => {
+            console.error('Error getting recommended courses:', error);
+            if (error.status === 401) {
+                console.log('Unauthorized access - user will be redirected to login');
+            }
+            else if (error.status !== 409) {
+                // Don't log error for 409 (already exists) as it's handled in the method
+                console.error('Failed to load course recommendations');
+            }
+            // Mark data as loaded even if there's an error to show the dialog content
+            this.dataLoaded = true;
+        });
+    }
+    // Progressive loading methods for course generation
+    startProgressiveLoading() {
+        this.currentProcessingStage = this.processingStages[0];
+        this.progressPercentage = 0;
+        this.stageStartTime = Date.now();
+        this.simulateProgressiveStages();
+    }
+    simulateProgressiveStages() {
+        let currentStageIndex = 0;
+        const totalDuration = 60000; // 60 seconds estimated duration
+        const stageInterval = totalDuration / this.processingStages.length;
+        const progressInterval = setInterval(() => {
+            const elapsed = Date.now() - this.stageStartTime;
+            const currentStageProgress = (elapsed % stageInterval) / stageInterval;
+            const stageIndex = Math.min(Math.floor(elapsed / stageInterval), this.processingStages.length - 1);
+            // Update stage if needed
+            if (stageIndex !== currentStageIndex && stageIndex < this.processingStages.length) {
+                currentStageIndex = stageIndex;
+                this.currentProcessingStage = this.processingStages[stageIndex];
+            }
+            // Calculate overall progress (each stage is worth ~16.67%)
+            const baseProgress = (stageIndex / this.processingStages.length) * 100;
+            const stageProgress = (currentStageProgress / this.processingStages.length) * 100;
+            this.progressPercentage = Math.min(Math.round(baseProgress + stageProgress), 95);
+            // Clear interval when loading stops
+            if (!this.loading) {
+                clearInterval(progressInterval);
+                this.progressPercentage = 100;
+                this.currentProcessingStage = 'Course recommendations generated successfully!';
+            }
+        }, 1000);
+    }
+    // Enhanced course generation with progressive loading
+    getRecommendedCourseWithProgress(role_mapping_id) {
+        return new Promise((resolve, reject) => {
+            this.loading = true;
+            this.currentProcessingStage = 'Generating course recommendations...';
+            this.progressPercentage = 30;
+            this.startProgressiveLoading();
+            interval(5000) // ⏱ poll every 5 seconds
+                .pipe(tap(() => {
+                this.currentProcessingStage = 'Processing...';
+            }), switchMap(() => this.sharedService.getRecommendedCourse(role_mapping_id)), 
+            // Continue polling while status !== COMPLETED
+            takeWhile((response) => response?.status !== 'COMPLETED', true), finalize(() => {
+                this.loading = false;
+            }))
+                .subscribe({
+                next: (response) => {
+                    if (response?.status === 'COMPLETED') {
+                        this.progressPercentage = 100;
+                        this.currentProcessingStage = 'Course recommendations generated successfully!';
+                        setTimeout(() => {
+                            this.currentProcessingStage = '';
+                            this.progressPercentage = 0;
+                        }, 2000);
+                        this.snackBar.open('Recommendations ready!', 'X', {
+                            duration: 3000,
+                            panelClass: ['snackbar-success']
+                        });
+                        resolve(response);
+                    }
+                },
+                error: (error) => {
+                    this.loading = false;
+                    this.currentProcessingStage = '';
+                    this.progressPercentage = 0;
+                    if (error.status === 409 || error.error?.detail?.includes('already exists')) {
+                        this.snackBar.open('Course recommendations already exist.', 'X', {
+                            duration: 3000,
+                            panelClass: ['snackbar-success']
+                        });
+                        resolve(null); // not a real error
+                    }
+                    else {
+                        this.snackBar.open('Failed to generate course recommendations.', 'X', {
+                            duration: 3000,
+                            panelClass: ['snackbar-error']
+                        });
+                        reject(error);
+                    }
+                }
+            });
+        });
+    }
+    resetFilters() {
+        this.filterForm.reset({
+            competency: [],
+            rating: [],
+            language: [],
+            duration: [],
+            provider: []
+        });
+        // Reset filtered dropdown lists
+        this.filteredCompetency = [...this.competenciesType];
+        this.filteredRatings = [...this.ratings];
+        this.filteredLanguages = [...this.languages];
+        this.filteredDurations = [...this.durations];
+        this.filteredProviders = [...this.providers];
+        // Reset course list
+        this.filterdCourses = [...this.fullCourseList];
+        // this.fullCourseList.forEach((item)=>{
+        //   if(item && item.organisation && item.organisation.length) {
+        //     if(this.filteredProviders.indexOf(item.organisation[0]) < 0) {
+        //       this.filteredProviders.push(item.organisation[0])
+        //     }
+        //   }
+        // })
+        this.getAllAvailableCourses();
+    }
+    filterList(value, type) {
+        const search = value.toLowerCase();
+        switch (type) {
+            case 'competency':
+                this.filteredCompetency = this.competenciesType.filter(v => v.toLowerCase().includes(search));
+                break;
+            case 'rating':
+                this.filteredRatings = this.ratings.filter(v => v.toLowerCase().includes(search));
+                break;
+            case 'language':
+                this.filteredLanguages = this.languages.filter(v => v.toLowerCase().includes(search));
+                break;
+            case 'duration':
+                this.filteredDurations = this.durations.filter(v => v.toLowerCase().includes(search));
+                break;
+            case 'provider':
+                this.filteredProviders = this.providers.filter(v => v.toLowerCase().includes(search));
+                break;
+        }
+    }
+    normalizeCompetency(value) {
+        if (!value)
+            return '';
+        const v = value.toLowerCase();
+        if (v === 'all')
+            return 'all';
+        if (v.includes('behavioural') || v.includes('behavioral'))
+            return 'behavioral';
+        if (v.includes('functional'))
+            return 'functional';
+        if (v.includes('domain'))
+            return 'domain';
+        return '';
+    }
+    applyFilters() {
+        const { competency = [], rating = [], language = [], duration = [], provider = [] } = this.filterForm.value;
+        console.log('this.fullCourseList--', this.fullCourseList);
+        this.filterdCourses = this.fullCourseList.filter(course => {
+            /* ---------------- Competency ---------------- */
+            const courseCompetencies = [
+                ...(course.competencies || []),
+                ...(course.competencies_v6 || [])
+            ];
+            const selectedCompetencies = competency
+                .map((c) => this.normalizeCompetency(c))
+                .filter(c => c !== '');
+            const competencyMatch = selectedCompetencies.length === 0 ||
+                selectedCompetencies.includes('all') ||
+                courseCompetencies.some((c) => selectedCompetencies.includes(this.normalizeCompetency(c.competencyAreaName)));
+            /* ---------------- Rating ---------------- */
+            const ratingMatch = rating.length === 0 ||
+                this.matchRating(course, rating);
+            /* ---------------- Language ---------------- */
+            const languageMatch = language.length === 0 ||
+                language.some((l) => course.language === l ||
+                    course.language?.includes?.(l) ||
+                    course.language?.[0]?.includes?.(l));
+            /* ---------------- Duration ---------------- */
+            const durationMatch = duration.length === 0 ||
+                this.matchDuration(course.duration, duration);
+            /* ---------------- Provider ---------------- */
+            const providerMatch = provider.length === 0 ||
+                provider.some((p) => course.organisation?.includes(p));
+            return (competencyMatch &&
+                ratingMatch &&
+                languageMatch &&
+                durationMatch &&
+                providerMatch);
+        });
+    }
+    matchRating(course, selectedRatings) {
+        if (!selectedRatings || selectedRatings.length === 0) {
+            return true; // no filter selected → match everything
+        }
+        let rating = null;
+        // 1️⃣ Use avgRating if available
+        if (course.avgRating != null && !isNaN(course.avgRating)) {
+            rating = Number(course.avgRating);
+        }
+        // 2️⃣ Map relevancy if avgRating missing
+        else if (course.relevancy != null && !isNaN(course.relevancy)) {
+            const rel = Number(course.relevancy);
+            if (rel >= 90)
+                rating = 4.5;
+            else if (rel >= 80)
+                rating = 4.0;
+            else if (rel >= 70)
+                rating = 3.5;
+            else if (rel >= 50)
+                rating = 2.5;
+            else
+                rating = 1.0;
+        }
+        // 3️⃣ No usable rating → exclude
+        if (rating === null)
+            return false;
+        // 4️⃣ Match selected rating ranges
+        return selectedRatings.some(r => {
+            switch (r) {
+                case '4.5 and above': return rating >= 4.5;
+                case '4.0 and above': return rating >= 4.0;
+                case '3.5 and above': return rating >= 3.5;
+                case '2.5 and above': return rating >= 2.5;
+                case '1 and above': return rating >= 1.0;
+                default: return false;
+            }
+        });
+    }
+    matchDuration(durationInSeconds, selectedRanges) {
+        const hours = Number(durationInSeconds) / 3600;
+        return selectedRanges.some(range => {
+            switch (range) {
+                case '< 1 Hour':
+                    return hours < 1;
+                case '1-5 Hours':
+                    return hours >= 1 && hours <= 5;
+                case '5+ Hours':
+                    return hours > 5;
+                default:
+                    return true;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GenerateCourseRecommendationComponent, deps: [{ token: i1.MatDialogRef }, { token: MAT_DIALOG_DATA }, { token: i2.SharedService }, { token: i3.MatSnackBar }, { token: i1.MatDialog }, { token: i4.FormBuilder }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: GenerateCourseRecommendationComponent, selector: "app-generate-course-recommendation", viewQueries: [{ propertyName: "pdfContent", first: true, predicate: ["pdfContent"], descendants: true }], ngImport: i0, template: "<div class=\"view-cbp-plan\">\n    <div class=\"popup-container\">\n        \n        <!-- Initial Loading Screen (for initial load and regeneration) -->\n        <div class=\"initial-loading-container\" *ngIf=\"!dataLoaded || isRegeneratingWithProgress\">\n            <div class=\"loading-content\">\n                <mat-spinner diameter=\"50\"></mat-spinner>\n                <div class=\"loading-text mt-3\">\n                    <p class=\"main-message\">{{ currentProcessingStage || (isRegeneratingWithProgress ? 'Regenerating course recommendations...' : 'Loading course recommendations...') }}</p>\n                    <div class=\"progress-details\" *ngIf=\"progressPercentage > 0\">\n                        <div class=\"progress-indicator\">\n                            <div class=\"progress-bar-container\">\n                                <div class=\"progress-bar\" \n                                     [style.width.%]=\"progressPercentage\">\n                                </div>\n                            </div>\n                            <small class=\"progress-text\">{{ progressPercentage }}% Complete</small>\n                        </div>\n                        <small class=\"time-estimate\">\n                            Real-time course generation in progress. This may take 1-2 minutes.\n                        </small>\n                    </div>\n                </div>\n            </div>\n        </div>\n\n        <!-- Main Content -->\n        <div class=\"main-content\" *ngIf=\"dataLoaded && !isRegeneratingWithProgress\">\n        <div class=\"popup-header\">\n            <div class=\"header-left\">\n                <div class=\"heading\">Save Courses (<span>{{sharedService?.cbpPlanFinalObj?.ministry?.orgName}} <span\n                            *ngIf=\"planData?.designation_name \">/ {{planData?.designation_name}}</span></span>)</div>\n            </div>\n            <div class=\"header-actions\">\n                <button class=\"regenerate-btn\" (click)=\"regenerateCourseRecommendations()\"\n                        [disabled]=\"isRegenerating\"\n                        mat-raised-button color=\"primary\">\n                    <mat-icon *ngIf=\"!isRegenerating\">refresh</mat-icon>\n                    <mat-spinner *ngIf=\"isRegenerating\" diameter=\"20\"></mat-spinner>\n                    <span>{{isRegenerating ? 'Regenerating...' : 'Regenerate Recommendations'}}</span>\n                </button>\n                <div class=\"cursor-pointer close-btn\" (click)=\"closeDialog()\">\n                    <mat-icon>close</mat-icon>\n                </div>\n            </div>\n        </div>\n        <div class=\"section-container mt-4\">\n            <mat-tab-group (selectedTabChange)=\"onOuterTabChange($event)\">\n                <!-- First Main Tab -->\n                <mat-tab label=\"course recommendation\">\n                    <!-- Nested Tabs -->\n                    <!-- <mat-tab-group (selectedTabChange)=\"onInnerTabChange($event)\">\n                        <mat-tab label=\"all\">\n\n                        </mat-tab>\n                        <mat-tab label=\"behavioural\">\n\n                        </mat-tab>\n                        <mat-tab label=\"functional\">\n\n                        </mat-tab>\n                        <mat-tab label=\"domain\">\n\n                        </mat-tab>\n                    </mat-tab-group> -->\n                </mat-tab>\n\n                <!-- Second Main Tab -->\n                <mat-tab label=\"gap analysis\">\n                    <!-- <p>Gap analysis content goes here</p> -->\n                </mat-tab>\n            </mat-tab-group>\n            <form [formGroup]=\"filterForm\" class=\"filters-container\">\n            <div class=\"role-mapping-container\"\n                *ngIf=\"outerTabActiveIndex === 0 && (innerTabActiveIndex === 0 || innerTabActiveIndex === 1 || innerTabActiveIndex === 2 || innerTabActiveIndex === 3 )\">\n                <div class=\"container\">\n                    <div class=\"section-header-improved mt-3\">\n                        <div class=\"search-and-buttons-container\">\n                            <div>\n                                <label>Search Courses</label>\n                            </div>                            \n                            <div class=\"search-container-compact\">\n                                <div class=\"rsearch\">\n                                    <mat-icon class=\"search-icon\">search</mat-icon>\n                                    <input class=\"sinput-compact\" [(ngModel)]=\"searchText\"\n                                           (input)=\"applyFilter($event.target.value);\"\n                                           placeholder=\"Search Courses\" type=\"text\">\n                                </div>\n                            </div>\n                            \n                        </div>\n                        \n\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Competency</label>\n                            </div>   \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.competency?.length ? '' : 'Competency' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"competency\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                        \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Competency\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'competency')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredCompetency\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>                       \n                            \n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Rating</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.rating?.length ? '' : 'Rating' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"rating\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Reatings\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'rating')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredRatings\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                       \n                      \n                        \n                        \n                    </div>\n                    <div class=\"section-header-improved-sec-2 mt-4\">\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Language</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.language?.length ? '' : 'Language' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"language\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Languages\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'language')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredLanguages\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Duration</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.duration?.length ? '' : 'Duration' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"duration\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Duration\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'duration')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredDurations\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Provider</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.provider?.length ? '' : 'Provider' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"provider\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Provider\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'provider')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredProviders\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div style=\"margin-top: 45px;margin-left: 20px;\">\n                            <input class=\"btn-active\" type=\"button\" value=\"Reset All Filters\"\n                                (click)=\"resetFilters()\" />\n                        </div>\n                    </div>\n                    <div class=\"mt-4\">\n                        <div style=\"font-size:16px;font-weight:bold;color:#000\">\n                            Filtered Course Count : {{filterdCourses?.length}}\n                        </div>\n                    </div>\n                    <div class=\"mt-5 sub-heading select-all-container\" *ngIf=\"filterdCourses?.length\">\n                        <div style=\"margin-left: 16px;\">\n                            <mat-checkbox [checked]=\"false\" (change)=\"selectAllCourses($event)\">Select All\n                                Courses</mat-checkbox>\n                        </div>\n                        <div class=\"btn-group-compact\">\n                            <div>\n                                <input class=\"btn-active\" type=\"button\" value=\"Suggest More Course From iGOT\"\n                                    (click)=\"suggestMoreCourses()\" />\n                            </div>\n                            <div class=\"pl-2\">\n                                <input [disabled]=\"selectFilterCourses?.length > 0 ? false : true\"\n                                    [ngClass]=\"selectFilterCourses?.length > 0 ? 'btn-active' : 'btn-disable'\"\n                                    type=\"button\" [value]=\"mode === 'add' ? 'Save Courses' : 'Update Courses'\"\n                                    (click)=\"saveCourses()\" />\n                            </div>\n                        </div>\n                    </div>\n                    <div class=\"disclaimer-container mt-2\" *ngIf=\"filterdCourses?.length\">\n                        <div class=\"disclaimer-message mt-4\">\n                            <strong>Disclaimer:</strong> Please verify the public course URL before adding it to the plan.\n                        </div>\n                    </div>\n                    <div class=\"mt-2\">\n\n                        <div class=\"course-list-container\">\n                            <div\n                                [ngClass]=\"innerTabActiveIndex > 0 ? 'course-list-container-flex':'course-list-container-right-flex' \">\n                                <div *ngIf=\"innerTabActiveIndex > 0\"\n                                    [ngClass]=\"innerTabActiveIndex > 0 ? 'left-panel':''\">\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 1\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Behavioural</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                             class=\"category-list-item cursor-pointer mt-2\"\n                                             [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                             *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 2\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Functional</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                             class=\"category-list-item cursor-pointer mt-2\"\n                                             [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                             *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 3\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Domain</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                            class=\"category-list-item cursor-pointer mt-2\"\n                                            [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                            *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                </div>\n                                <div [ngClass]=\"innerTabActiveIndex > 0 ? 'right-panel':'right-panel-flex'\">\n                                    <!-- No Course Found Message in Right Panel -->\n                                    <div class=\"no-course-found-container\"\n                                        *ngIf=\"filterdCourses?.length === 0 && selectedThemeFilter\">\n                                        <div class=\"no-course-card\">\n                                            <div class=\"no-course-icon\">\n                                                <mat-icon>search_off</mat-icon>\n                                            </div>\n                                            <div class=\"no-course-content\">\n                                                <h4>No Courses Found</h4>\n                                                <p>No courses found for the selected theme:\n                                                    <strong>{{selectedThemeFilter}}</strong></p>\n                                                <p>Would you like to add a course for this competency?</p>\n                                                <button class=\"suggest-course-btn\"\n                                                    (click)=\"addCourseForSelectedTheme()\">\n                                                    <mat-icon>add_circle</mat-icon>\n                                                    Add Course\n                                                </button>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <!-- Courses List -->\n                                    <div class=\"course-list-item\" *ngFor=\"let item of filterdCourses;let i=index\">\n\n                                        <div class=\"course-content\">\n                                            <div class=\"course-header\">\n                                                <div class=\"checked-course-container\">\n                                                    <div>\n                                                        <mat-checkbox [checked]=\"checkIfCourseExists(item)\"\n                                                            (change)=\"selectedFilterCourses($event, item)\"></mat-checkbox>\n                                                    </div>\n                                                    <div class=\"ml-2\">\n                                                        <div class=\"course-pill-container\">\n                                                            <div class=\"course-pill\">\n                                                                <div class=\"course-pill-text\">\n                                                                    <span><img\n                                                                            src=\"assets/icons/course.svg\"></span>&nbsp;<span>Course</span>\n                                                                </div>\n                                                            </div>\n                                                        </div>\n                                                    </div>\n\n                                                </div>\n\n                                                <!-- <div>\n                                        <div class=\"ai-recommened-pill\">\n                                            <div class=\"ai-recommened-pill-text\">\n                                                <span class=\"ai-loader-icon\"><img src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                <span *ngIf=\"item?.rationale\">AI Recommended\n                                                    <span *ngIf=\"item?.is_public\"> - Public</span>\n                                                    <span *ngIf=\"!item?.is_public\"> - iGOT</span>\n                                                </span>\n                                                <span *ngIf=\"!item?.rationale\">Manually Suggested - iGOT</span>\n\n                                            </div>\n                                        </div>\n                                    </div> -->\n                                                <div *ngIf=\"item?.rationale && !item?.is_public\">\n                                                    <div class=\"ai-recommened-pill-green\">\n                                                        <div class=\"ai-recommened-pill-green-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>AI Recommended - iGOT </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n                                                <div *ngIf=\"item?.rationale && item?.is_public\">\n                                                    <div class=\"ai-recommened-pill-public\">\n                                                        <div class=\"ai-recommened-pill-public-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>AI Recommended - Public </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n                                                <div *ngIf=\"!item?.rationale\">\n                                                    <div class=\"ai-recommened-pill-gray\">\n                                                        <div class=\"ai-recommened-pill-gray-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>Manually Suggested - iGOT </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n\n                                            </div>\n                                            <div class=\"course-title mt-3 cursor-pointer\" (click)=\"redirectToToc(item)\">\n                                                <span *ngIf=\"item?.course\">{{item?.course}}</span>\n                                                <!-- <span *ngIf=\"item?.name\">{{item?.name}}****</span> -->\n                                                <span style=\"margin-left:10px;\" (click)=\"redirectToToc(item)\"><img\n                                                        height=\"18px\" width=\"18px\"\n                                                        src=\"assets/icons/redirect.png\" /></span>\n                                            </div>\n                                            <div class=\"course-desc mt-2\">\n                                                <!-- <span *ngIf=\"item?.rationale\">{{item?.rationale}}</span> -->\n                                                <span *ngIf=\"item?.description\">{{item?.description}}</span>\n                                            </div>\n                                            <div class=\"mt-3\" *ngIf=\"getCompetenciesByType('Behavioural',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Behavioural Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"behavioural-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Behavioural',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Behavioural',i)\"\n                                                        class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Behavioural',i)\">\n                                                            {{ isExpanded('Behavioural',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Behavioural',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n                                            <div class=\"mt-2\" *ngIf=\"getCompetenciesByType('Functional',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Functional Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"functional-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Functional',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Functional',i)\"\n                                                        class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Functional',i)\">\n                                                            {{ isExpanded('Functional',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Functional',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n                                            <div class=\"mt-2\" *ngIf=\"getCompetenciesByType('Domain',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Domain Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"domain-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Domain',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Domain',i)\" class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Domain',i)\">\n                                                            {{ isExpanded('Domain',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Domain',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n\n\n                                        </div>\n\n                                        <!-- Relevancy and Duration section -->\n                                        <div class=\"course-footer\" *ngIf=\"item?.relevancy\">\n                                            <div class=\"relevancy-pill-green\">\n                                                <div class=\"relevancy-container\">\n                                                    <div class=\"relevancy\">Relevancy</div>\n                                                    <div class=\"dash\">-</div>\n                                                    <div class=\"percentage\">{{item?.relevancy}}%</div>\n                                                </div>\n                                            </div>\n                                            <div class=\"relevancy-pill-green\">\n                                                <div class=\"relevancy-container\">\n                                                    <div class=\"relevancy\">Duration</div>\n                                                    <div class=\"dash\">-</div>\n                                                    <div class=\"percentage\">\n                                                        <span\n                                                            *ngIf=\"item?.duration\">{{getDuration(item?.duration)}}</span>\n                                                        <span *ngIf=\"!(item?.duration)\">N/A</span>\n                                                    </div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                    </div>\n                                </div>\n                            </div>\n                        </div>\n                    </div>\n\n                    <!-- General No Data Message (only when no theme filter is active) -->\n                    <div class=\"mt-2 sub-heading\" *ngIf=\"filterdCourses?.length === 0 && !selectedThemeFilter\">\n                        <p>No Data Found</p>\n                    </div>\n                </div>\n            </div>\n        </form>\n            <div class=\"role-mapping-container\" *ngIf=\"outerTabActiveIndex === 1\">\n                <div id=\"gap-analysis-content\">\n\n                    <div class=\"download-pdf mt-4 mb-2\">\n                        <div>\n                            <input class=\"btn-active\" type=\"button\" value=\"Download\" (click)=\"downloadPDF()\" />\n                        </div>\n                    </div>\n                    <div>\n                        <!-- <div *ngIf=\"isPDFDownload\">\n                            <div class=\"pdf-heading\">{{sharedService?.cbpPlanFinalObj?.ministry?.name}} <span\n                                    *ngIf=\"planData?.designation_name \">_{{planData?.designation_name}}_Gap_Analysis</span>\n                            </div>\n                        </div> -->\n                        <div class=\"d-flex vh-100\" [ngClass]=\"isPDFDownload ? 'mt-4':''\">\n                            <!-- Sidebar -->\n                            <div class=\"d-flex flex-column p-3 bg-light border-end\" style=\"width: 250px;\">\n                                <h5 class=\"mb-4\">Analyze by Category</h5>\n                                <button *ngFor=\"let item of menuItems\"\n                                    class=\"btn btn-outline-primary mb-2 text-start menu-list-item\"\n                                    [class.active]=\"selectedCategory === item.key\" (click)=\"selectCategory(item.key)\">\n                                    {{ item.label }}\n                                </button>\n                            </div>\n\n                            <!-- Main Content -->\n                            <div class=\"flex-grow-1 p-4\">\n                                <div class=\"d-flex justify-content-between gap-3 \">\n                                    <div class=\"p-3 gray-bg\">\n                                        <div class=\"div-label sub-heading\">\n                                            <p>Competencies Covered</p>\n                                        </div>\n                                        <div class=\"div-count\">{{competencyCoveredCount}}</div>\n                                    </div>\n                                    <div class=\"p-3 gray-bg\">\n                                        <div class=\"div-label sub-heading\">\n                                            <p *ngIf=\"selectedCategory === 'all'\">Total Competencies</p>\n                                            <p *ngIf=\"selectedCategory === 'behavioral'\">Total Behavioural Competencies\n                                            </p>\n                                            <p *ngIf=\"selectedCategory === 'functional'\">Total Functional Competencies\n                                            </p>\n                                            <p *ngIf=\"selectedCategory === 'domain'\">Total Domain Competencies</p>\n                                        </div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'all'\">\n                                            {{this.planData?.competencies?.length}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            {{behavioralTotalCompetencies}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'functional'\">\n                                            {{functionalTotalCompetencies}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'domain'\">\n                                            {{domainTotalCompetencies}}</div>\n                                    </div>\n                                    <div class=\"p-3 green-bg\">\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'all'\">Overall Coverage\n                                        </div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            Behavioural Coverage</div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'functional'\">\n                                            Functional Coverage</div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'domain'\">Domain\n                                            Coverage</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'all'\">\n                                            {{overallCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            {{behavioralCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'functional'\">\n                                            {{functionalCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'domain'\">\n                                            {{domainCoverage}}</div>\n                                    </div>\n                                </div>\n                                <div class=\"mt-4 all-category-list\" [ngSwitch]=\"selectedCategory\">\n                                    <div *ngSwitchCase=\"'all'\">\n                                        <h4>All Categories</h4>\n\n                                        <!-- Show Behavioural section only if there are unmatched behavioural competencies -->\n                                        <div class=\"mt-4\"\n                                            *ngIf=\"behaviouralNotMatched && behaviouralNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Behavioural</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of behaviouralNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Behavioral')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show Functional section only if there are unmatched functional competencies -->\n                                        <div class=\"mt-4\"\n                                            *ngIf=\"functionalNotMatched && functionalNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Functional</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of functionalNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Functional')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show Domain section only if there are unmatched domain competencies -->\n                                        <div class=\"mt-4\" *ngIf=\"domainNotMatched && domainNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Domain</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of domainNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Domain')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show message when all competencies are covered -->\n                                        <div class=\"mt-4 text-center\"\n                                            *ngIf=\"(!behaviouralNotMatched || behaviouralNotMatched.length === 0) && \n                                                                           (!functionalNotMatched || functionalNotMatched.length === 0) && \n                                                                           (!domainNotMatched || domainNotMatched.length === 0)\">\n                                            <div class=\"no-gaps-message\">\n                                                <mat-icon class=\"success-icon\">check_circle</mat-icon>\n                                                <h4>Excellent! All competencies are covered</h4>\n                                                <p>All required competencies have been addressed by the selected\n                                                    courses.</p>\n                                            </div>\n                                        </div>\n\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'behavioral'\">\n                                        <h4>Behavioural</h4>\n                                        <div class=\"mt-4\" *ngIf=\"behavioralCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Behavioural</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of behaviouralNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Behavioral')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course </span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"behavioralCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    \uD83C\uDF89 Excellent! All behavioral competencies are covered by the\n                                                    selected courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'functional'\">\n                                        <h4>Functional</h4>\n                                        <div class=\"mt-4\" *ngIf=\"functionalCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Functional</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of functionalNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Functional')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"functionalCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    \uD83C\uDF89 Excellent! All functional competencies are covered by the\n                                                    selected courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'domain'\">\n                                        <h4>Domain</h4>\n                                        <div class=\"mt-4\" *ngIf=\"domainCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Domain</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of domainNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Domain')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course </span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"domainCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    \uD83C\uDF89 Excellent! All domain competencies are covered by the selected\n                                                    courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchDefault>\n                                        <p>Please select a category.</p>\n                                    </div>\n                                </div>\n                            </div>\n                        </div>\n                    </div>\n                </div>\n\n            </div>\n        </div>\n        </div> <!-- Close main-content div -->\n\n    </div>\n</div>\n\n\n<div [hidden]=\"!isPDFDownload\" class=\"gap-analysis-pdf-container\" #pdfContent>\n    <div class=\"gap-analysis-pdf-header\">\n      <img src=\"assets/icons/karmayogiLogo-min.png\" alt=\"Karmayogi Bharat Logo\" class=\"logo\" />\n      <h1><span>\n        <span *ngIf=\"sharedService?.cbpPlanFinalObj?.ministry?.sbOrgType === 'state'\">{{sharedService?.cbpPlanFinalObj?.department_name?.name}}</span> \n        <span *ngIf=\"sharedService?.cbpPlanFinalObj?.ministry?.sbOrgType === 'ministry'\">{{sharedService?.cbpPlanFinalObj?.ministry?.name}}</span>   \n        <span *ngIf=\"planData?.designation_name \">/ {{planData?.designation_name}}</span>\n        </span></h1>\n      <p class=\"subtitle\">A detailed breakdown of competencies Gap Analysis</p>\n     \n    </div>\n  \n    <div class=\"competency-snapshot\">\n      <h2>Competency Snapshot</h2>\n      <div class=\"snapshot-content\">\n        <div class=\"circle-wrapper\">\n          <svg class=\"progress-ring\" width=\"120\" height=\"120\">\n            <circle class=\"progress-ring-bg\" cx=\"60\" cy=\"60\" r=\"52\" />\n            <circle class=\"progress-ring-circle\" cx=\"60\" cy=\"60\" r=\"52\" />\n          </svg>\n          <div class=\"percentage-text\">{{overallCoverage}}<br /><span>Overall Coverage</span></div>\n        </div>\n  \n        <div class=\"competency-container\">\n            <!-- Total Competencies Box -->\n            <div class=\"total-box\">\n              <div class=\"title\">Total Competencies</div>\n              <div class=\"count\">{{this.planData?.competencies?.length}}</div>\n            </div>\n          \n            <!-- Progress Bars -->\n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text behavioral\">Behavioural</span>\n                <span class=\"covered-text\">{{behavioralCompetencyCoveredCount}} / {{behavioralTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill behavioral\" [style.width.%]=\"(behavioralCompetencyCoveredCount / behavioralTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          \n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text functional\">Functional</span>\n                <span class=\"covered-text\">{{functionalCompetencyCoveredCount}} / {{functionalTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill functional\" [style.width.%]=\"(functionalCompetencyCoveredCount / functionalTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          \n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text domain\">Domain</span>\n                <span class=\"covered-text\">{{domainCompetencyCoveredCount}} / {{domainTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill domain\" [style.width.%]=\"(domainCompetencyCoveredCount / domainTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          </div>\n      </div>\n    </div>\n  \n    <div class=\"gap-section mb-4\">\n      <h2>Detailed Competency Analysis</h2>\n      <div class=\"gap-box\">\n        Bridge Your Competencies Gap\n        <p class=\"subtitle\">Here are {{this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)}} key areas for development.</p>\n    </div>\n    </div>\n    <div class=\"sub-heading mb-4\">\n        <p>Gap to Address <span *ngIf=\"(this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)) > 0\">({{this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)}})</span></p>\n        \n    </div>\n    <div class=\"competency-card behavioral\" *ngFor=\"let item of behaviouralNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n          &nbsp; \u2022 &nbsp;\n          <span class=\"tag behavioral\">Behavioural</span>\n        </div>\n    </div>\n      \n      <div class=\"competency-card functional\" *ngFor=\"let item of functionalNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n           &nbsp; \u2022 &nbsp;\n          <span class=\"tag functional\">Functional</span>\n        </div>\n      </div>\n      \n      <div class=\"competency-card domain\" *ngFor=\"let item of domainNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n          <!-- Project Management  -->\n          &nbsp; \u2022 &nbsp;\n          <span class=\"tag domain\">Domain</span>\n        </div>\n      </div>\n      <div class=\"sub-heading mb-4\">\n        <p>Covered Competencies <span>({{this.planData?.competencies?.length - (behaviouralNotMatched?.length + functionalNotMatched?.length + domainNotMatched?.length)}})</span></p>        \n     </div>\n     <div class=\"gap-section mb-4\">\n        \n        <div class=\"green-bg\">\n            <div class=\"div-green-label mb-2\">\n                Congratulations!\n            </div>            \n            <p>You have successfully covered </p>\n          <p class=\"subtitle\">{{this.planData?.competencies?.length - (behaviouralNotMatched?.length + functionalNotMatched?.length + domainNotMatched?.length)}} key competencies, forming a strong professional foundation.</p>\n      </div>\n      </div>\n      <div class=\"competency-card behavioral\" *ngFor=\"let item of behaviouralMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n          {{item?.sub_theme}}&nbsp; \u2022 &nbsp;\n          <span class=\"tag behavioral\">Behavioural</span>\n        </div>\n    </div>\n      \n      <div class=\"competency-card functional\" *ngFor=\"let item of functionalMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n            {{item?.sub_theme}}&nbsp; \u2022 &nbsp;\n          <span class=\"tag functional\">Functional</span>\n        </div>\n      </div>\n      \n      <div class=\"competency-card domain\" *ngFor=\"let item of domainMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n          <!-- Project Management  -->\n          {{item?.sub_theme}}&nbsp; \u2022 &nbsp;\n          <span class=\"tag domain\">Domain</span>\n        </div>\n      </div>\n      <div class=\"gap-section mb-4\">\n        <h2>Recommended Courses</h2>\n      </div>\n      <app-gap-analysis-recommended-course [planData]=\"planData\"></app-gap-analysis-recommended-course>\n</div>\n  \n\n\n<div class=\"overlay-loader\" *ngIf=\"loading && dataLoaded && !isRegeneratingWithProgress\">\n    <div class=\"loading-content\">\n        <mat-spinner diameter=\"50\"></mat-spinner>\n        <div class=\"loading-text mt-3\">\n            <p class=\"main-message\">{{ currentProcessingStage || 'Preparing course recommendation generation...' }}</p>\n            <div class=\"progress-details\">\n                <div class=\"progress-indicator\" *ngIf=\"progressPercentage > 0\">\n                    <div class=\"progress-bar-container\">\n                        <div class=\"progress-bar\" \n                             [style.width.%]=\"progressPercentage\">\n                        </div>\n                    </div>\n                    <small class=\"progress-text\">{{ progressPercentage }}% Complete</small>\n                </div>\n                <small class=\"time-estimate\">\n                    Real-time course generation in progress. This may take 1-2 minutes.\n                </small>\n            </div>\n        </div>\n    </div>\n</div>", styles: ["@charset \"UTF-8\";.container{margin:10px auto}.sub-heading p{color:#000;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal}.radio-label{color:#000;font-family:Lato;font-size:16px;font-style:normal;font-weight:400;line-height:normal}.radio-btn-group{display:flex;width:32px;height:32px;padding:2px;gap:10px}.label{color:var(--Body-Text-Body-Color, #212529);font-family:Lato;font-size:16px;font-style:normal;font-weight:700;line-height:150%}::ng-deep mat-form-field{background-color:#fff!important;border-radius:25px!important;padding-left:12px;padding-right:12px;height:42px;width:100%}::ng-deep mat-select{border-radius:25px!important;background-color:#fff!important}::ng-deep .mat-select-panel{background-color:#fff!important}::ng-deep .mat-select-panel .mat-option{border-radius:0!important}::ng-deep mat-form-field .mat-form-field-underline{display:none!important}::ng-deep mat-select .mat-select-placeholder{color:#0006;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal}::ng-deep mat-select .mat-select-value-text{color:#000;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal;line-height:normal!important;padding-top:0!important;padding-bottom:0!important}::ng-deep mat-select .mat-select-value{display:flex!important;align-items:center!important;height:100%!important}.additional-details textarea{display:flex;padding:16px 16px 0;flex-direction:column;align-items:flex-start;gap:10px;flex:1 0 0;align-self:stretch;width:100%;color:#000;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal;resize:none}.section-header{display:flex;flex-direction:row;align-items:center;justify-content:space-between}.btn-disable{border-radius:var(--Radius-Full-Round, 9999999px);opacity:.4;background:var(--Primary-KB-Primary-Light, #1B4CA1);color:var(--white-kb-white-100, #FFF);text-align:center;font-family:Lato;font-size:14px;font-style:normal;font-weight:700;line-height:normal;display:flex;height:32px;padding:0 16px;justify-content:center;align-items:center;gap:8px;border:none}.btn-group{display:flex;flex-direction:row;justify-content:space-between}.pl-2{padding-left:5px}.search-filter-section{display:flex;flex-direction:row;justify-content:space-between}.search .rsearch{position:relative}.search .search-icon{position:absolute;top:15px;font-size:20px;left:10px}.search .sinput{border-radius:32px;border:1px solid #d5d0d0;padding:15px 36px;font:400 14px Lato;width:800px}.select-map-route-container{display:flex;flex-direction:row}.selected-mapping-route p{color:#1b4ca1;font-family:Lato;font-size:20px;font-style:normal;font-weight:400;line-height:normal;text-decoration-line:underline;text-decoration-style:solid;-webkit-text-decoration-skip:ink;text-decoration-skip-ink:auto;text-decoration-thickness:auto;text-underline-offset:auto;text-underline-position:from-font}.edit-plan{display:flex;padding:4px;justify-content:center;align-items:center;gap:8px;border-radius:4px;background:#1b4ca129;color:#1b4ca1;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal;margin-left:10px}.search-container{display:flex;flex-direction:row}.course-container{display:flex;width:100%;padding:16px;flex-direction:column;align-items:flex-start;gap:24px;grid-row:2/span 1;grid-column:1/span 1;border-radius:12px;border:1px solid var(--borders-black-border-16-black, rgba(0, 0, 0, .16));background:#fff}.course-header{display:flex;flex-direction:row;justify-content:space-between;align-items:flex-start;width:100%;gap:8px}.course-pill{display:flex;height:24px;padding:8px;align-items:center;gap:4px;border-radius:16px;border:1px solid var(--borders-border-fill-focussed-4-light-100, #EF951E);background:#fefaf4}.ai-recommened-pill-green{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#0080001c}.ai-recommened-pill-green-text{color:#006400;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-public{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#1b4ca129}.ai-recommened-pill-public-text{color:#1b4ca1;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-gray{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#d3d3d3}.ai-recommened-pill-gray-text{color:#000;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-orange{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#ffa50052}.ai-recommened-pill-orange-text{color:#5a3f0d;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-orange-text a{color:#5a3f0d!important;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.igot-platform-pill{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);border:1px solid #EF951E;background:#ef951e29}.course-title{color:var(--Primary-KB-Primary-Light, #1B4CA1);font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:22px}.course-desc{color:#0009;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:1.4;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;text-overflow:ellipsis}.relevancy,.competencies-matched{color:#6c757d;font-family:Lato;font-size:12px;font-style:normal;font-weight:500;line-height:normal;align-items:center}.percentage{color:#1b4ca1;font-family:Lato;font-size:14px;font-style:normal;font-weight:600;line-height:normal}.relevancy-container,.competencies-matched-container{display:flex;flex-direction:row;align-items:center}.dash{padding:0 5px}::ng-deep .mat-radio-checked .mat-radio-inner-circle{background:#1b4ca1!important}.course-list-container{display:flex;flex-wrap:wrap;gap:16px;width:100%;padding:1rem}.course-list-item{flex:1 1 calc(50% - 10px);min-width:350px;max-width:500px;box-sizing:border-box;border:1px solid #e0e0e0;padding:16px;background-color:#fff;border-radius:12px;min-height:auto;box-shadow:0 2px 4px #0000001a;transition:box-shadow .2s ease;display:flex;flex-direction:column}.course-list-item:hover{box-shadow:0 4px 8px #00000026}.course-list-item:only-child{flex:1 1 auto;max-width:800px}.checked-course-container{display:flex;width:60%}.ml-2{margin-left:8px}::ng-deep .mat-checkbox-checked .mat-checkbox-background{background:#1b4ca1!important}.igot-platform-pill-text{color:#1b4ca1;font-family:Lato;font-size:12px;font-style:normal;font-weight:700;line-height:normal}.course-pill-text{color:var(--accessbility-shades-without-opacity-kb-greys-black-87, #212121);text-align:center;font-family:Poppins;font-size:12px;font-style:normal;font-weight:400;line-height:normal}.ai-loader-icon img,.igot-platform-icon img{width:15.714px;height:15.714px;flex-shrink:0}.competency-container{display:flex;justify-content:space-between;flex-direction:row}.outside-layer-total{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #1B4CA1;background:#edf1f8;width:132px}.outside-layer-functional{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #E24577;background:#f8d2de;width:132px}.outside-layer-domain{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #7B47A4;background:#dfd3e9;width:132px}.outside-layer-behavioral{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #F8B861;background:#fde8cc;width:132px}.inside-layer{color:#1b4ca1;font-family:Lato;font-size:12px;font-style:normal;font-weight:400;line-height:normal}.count{color:#1b4ca1;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal}.suggest-courses-header{display:flex;flex-direction:row;justify-content:space-between}.suggest-course-control{display:flex;flex-direction:row}.course-card-container{width:172px;border-radius:3.307px;border:.827px solid var(--borders-border-8-black, rgba(0, 0, 0, .08));background-color:#fff}.highlight-ai{font-family:Montserrat;font-size:24px;font-style:normal;font-weight:600;line-height:normal;background:linear-gradient(90deg,#3b27ff,#2de3d6);background-clip:text;-webkit-background-clip:text;color:transparent;-webkit-text-fill-color:transparent;display:inline-block}.ai-loader-icon-medium img{width:40px;height:40px;flex-shrink:0}.heading{color:#000;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal;margin:10px 0}.pdf-heading{color:#000;font-family:Montserrat;font-size:18px;font-style:normal;font-weight:600;line-height:normal;margin:10px 0;text-align:center}.popup-header{display:flex;justify-content:space-between;align-items:center;padding:16px;border-bottom:1px solid #e0e0e0}.header-left{flex:1}.header-actions{display:flex;align-items:center;gap:12px}.regenerate-btn{display:flex;align-items:center;gap:8px;padding:8px 16px;border-radius:6px;font-size:14px;font-weight:500;min-width:auto}.regenerate-btn .mat-icon{margin:0;font-size:18px;width:18px;height:18px}.regenerate-btn .mat-spinner{margin:0}.regenerate-btn:disabled{opacity:.7;cursor:not-allowed}.close-btn{padding:8px;border-radius:4px;transition:background-color .2s ease}.close-btn:hover{background-color:#f5f5f5}.close-btn .mat-icon{font-size:20px;width:20px;height:20px}.progress-popup{display:flex;flex-direction:column;justify-content:center;align-items:center}.progress-popup .desc{color:#000000de;text-align:center;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal}.behavioural-pill{display:flex;padding:2px 6px;justify-content:center;align-items:center;gap:4px;border-radius:16px;border:1px solid #F8B861;background:linear-gradient(0deg,#f8b86152 0% 100%),#fff;margin:2px 4px 2px 0;font-size:12px}.functional-pill{display:flex;padding:2px 6px;justify-content:center;align-items:center;gap:4px;border-radius:16px;border:1px solid #E24577;background:linear-gradient(0deg,#e245773d 0% 100%),#fff;margin:2px 4px 2px 0;font-size:12px}.domain-pill{display:flex;padding:2px 6px;justify-content:center;align-items:center;gap:4px;border-radius:16px;border:1px solid #7B47A4;background:linear-gradient(0deg,#7b47a43d 0% 100%),#fff;margin:2px 4px 2px 0;font-size:12px}.popup-header{display:flex;flex-direction:row;justify-content:space-between}.popup-footer{display:flex;flex-direction:row;justify-content:end}.view-cbp-plan{margin:10px;padding:10px}.view-cbp-plan-popup{padding:24px;max-height:70vh;overflow-y:auto}.section{border-radius:8px;background:#1b4ca114;padding:16px}.popup-header{display:flex;justify-content:space-between;align-items:center;border-bottom:1px solid #ddd;font-weight:700;flex-shrink:0}.popup-footer{display:flex;justify-content:flex-end;gap:16px;padding:16px 24px;border-top:1px solid #ddd;background-color:#fff;flex-shrink:0;position:sticky;bottom:0}.section-container{overflow-y:auto;flex:1 1 auto}.competency-list{display:flex;flex-direction:row;gap:0px;flex-wrap:wrap;margin:0;padding:0;list-style:none}.competency-text{color:#000;font-family:Lato;font-size:12px;font-style:normal;font-weight:400;line-height:normal;padding:3px 6px}.competency-text-behavioral{color:#654321;font-family:Lato;font-size:14px;font-style:normal;line-height:normal;font-weight:550}.competency-text-functional{color:#b01669;font-family:Lato;font-size:14px;font-style:normal;line-height:normal;font-weight:550}.competency-text-domain{color:#301934;font-family:Lato;font-size:14px;font-style:normal;line-height:normal;font-weight:550}.competency-sub-heading{color:#1b4ca1;font-family:Montserrat;font-size:14px;font-style:normal;font-weight:600;line-height:normal}.cursor-pointer{cursor:pointer}.btn-active{border-radius:var(--Radius-Full-Round, 9999999px);opacity:1;background:var(--Primary-KB-Primary-Light, #1B4CA1);color:var(--white-kb-white-100, #FFF);text-align:center;font-family:Lato;font-size:14px;font-style:normal;font-weight:700;line-height:normal;display:flex;height:32px;padding:0 16px;justify-content:center;align-items:center;gap:8px;border:none}.custom-textarea{color:#000;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal}.initial-loading-container{display:flex;justify-content:center;align-items:center;min-height:400px;width:100%}.initial-loading-container .loading-content{display:flex;flex-direction:column;align-items:center;text-align:center;padding:3rem 2rem}.initial-loading-container .loading-content .loading-text{color:#1b4ca1;font-family:Lato,sans-serif;min-width:320px}.initial-loading-container .loading-content .loading-text .main-message{font-size:16px;font-weight:600;margin-bottom:1rem;color:#1b4ca1}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator{margin-bottom:.5rem}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container{width:300px;height:8px;background-color:#e0e0e0;border-radius:4px;overflow:hidden;margin-bottom:.5rem}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container .progress-bar{height:100%;background:linear-gradient(90deg,#1b4ca1,#4caf50);border-radius:4px;transition:width .3s ease-in-out}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator .progress-text{font-size:12px;color:#666;font-weight:500}.initial-loading-container .loading-content .loading-text .progress-details .time-estimate{font-size:12px;color:#888;font-style:italic}.overlay-loader{position:fixed;top:0;left:0;width:100vw;height:100vh;background:#ffffffbf;z-index:9999;display:flex;justify-content:center;align-items:center}.overlay-loader .loading-content{display:flex;flex-direction:column;align-items:center;text-align:center;background:#fff;padding:2rem;border-radius:8px;box-shadow:0 4px 12px #00000026}.overlay-loader .loading-content .loading-text{color:#1b4ca1;font-family:Lato,sans-serif;min-width:320px}.overlay-loader .loading-content .loading-text .main-message{margin:0 0 16px;font-size:18px;font-weight:600;text-align:center}.overlay-loader .loading-content .loading-text .progress-details{margin-top:16px}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator{margin-bottom:12px}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container{width:100%;height:8px;background-color:#e0e0e0;border-radius:4px;overflow:hidden;margin-bottom:8px}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container .progress-bar{height:100%;background:linear-gradient(90deg,#1b4ca1,#2563eb);border-radius:4px;transition:width .5s ease-in-out}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator .progress-text{font-size:14px;font-weight:500;color:#1b4ca1;display:block;text-align:center}.overlay-loader .loading-content .loading-text .progress-details .time-estimate{color:#666;font-size:12px;font-style:italic;display:block;text-align:center;margin-top:8px}.competencis-grid{display:flex;flex-direction:row;justify-content:space-between;gap:16px}.grid-list-item-behavioral div{border-left:2px solid darkorange}.grid-list-item-functional div{border-left:2px solid #ff1493}.grid-list-item-domain div{border-left:2px solid #6b21a8}.competencies-grid-3{width:33%}.bg-blue-50{background-color:#fde8cc;border-radius:4px}.bg-green-50{background-color:#f8d2de;border-radius:4px}.bg-purple-50{background-color:#dfd3e9;border-radius:4px}.grid-list-item div{padding:5px 10px;margin:10px 0}.course-pill-container{display:flex;gap:8px}.relevancy-pill-green{display:flex;padding:4px 8px;align-items:center;gap:4px;border-radius:16px;border:1px solid #e0e0e0;background:#f8f9fa}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.show-more-competency{display:inline-flex;align-items:center}.show-more-link{color:#1b4ca1;font-family:Lato;font-size:12px;font-style:normal;font-weight:500;line-height:normal;margin:2px 4px 2px 0;text-decoration:none}.show-more-link:hover{text-decoration:underline}.course-content{flex:1;display:flex;flex-direction:column}.course-footer{margin-top:auto;padding-top:12px;display:flex;justify-content:space-between}::ng-deep .mdc-tab__text-label{font-weight:700;font-family:Montserrat!important;font-size:16px;color:#000!important;text-transform:capitalize}.competency-tag{display:inline-block;padding:.25rem .75rem;border-radius:9999px;font-size:.75rem;font-weight:500;margin-right:.5rem;margin-bottom:.5rem}.menu-list-item.active{background-color:#1b4ca1;color:#fff}.menu-list-item:hover{background-color:#1b4ca1;color:#fff;border-color:#1b4ca1}.gray-bg{background-color:rgb(248,250,252,var(--tw-bg-opacity, 1));border-radius:8px;border:1px solid #ccc}.div-count{font-family:Lato;font-size:20px;font-weight:700}.green-bg{background-color:#0080001c;border:1px solid #006400;border-radius:8px}.div-green-count{font-family:Lato;font-size:20px;font-weight:700;color:#006400}.div-green-label{color:#006400;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal}.gray-bg-item{background-color:rgb(248,250,252,var(--tw-bg-opacity, 1));border-radius:8px;border:1px solid #ccc;padding:4px 8px;margin:10px}.add-btn{color:#1b4ca1;font-size:14px;font-family:Lato}.list-flex{display:flex;flex-direction:row;justify-content:space-between}.all-category-list .mat-icon{vertical-align:middle}.course-list-container-flex{display:flex;align-items:flex-start;gap:2rem}.left-panel{flex:0 0 250px;font-weight:700;text-align:left}.right-panel{flex:1;display:flex;flex-direction:row;flex-wrap:wrap;gap:20px;align-content:flex-start;justify-content:flex-start}.category-list-item{font-weight:400;font-size:16px;font-family:Lato;padding:5px}.right-panel-flex{display:flex;flex:0 0 100%;width:100%;flex-direction:row;flex-wrap:wrap;gap:20px;justify-content:flex-start}.course-list-container-right-flex{display:flex}.no-gaps-message{display:flex;flex-direction:column;align-items:center;padding:24px;background:linear-gradient(135deg,#4caf501a,#81c7841a);border:2px solid #4CAF50;border-radius:16px;margin:16px 0}.no-gaps-message .success-icon{font-size:25px;color:#4caf50;margin-bottom:16px}.no-gaps-message h4{color:#2e7d32;font-family:Montserrat;font-size:20px;font-weight:600;margin:0 0 8px;text-align:center}.no-gaps-message p{color:#388e3c;font-family:Lato;font-size:14px;font-weight:400;margin:0;text-align:center;line-height:1.5}.section-header-improved,.section-header-improved-sec-2{display:flex;flex-direction:row;gap:0px;width:100%}.search-and-buttons-container{display:flex;justify-content:space-between;gap:5px;flex-direction:column;flex-wrap:wrap;width:37%;margin:0 5px}.search-container-compact{flex:0 0 auto;min-width:180px}.search-container-compact .rsearch{position:relative;display:flex;align-items:center}.search-container-compact .search-icon{position:absolute;left:12px;color:#666;font-size:20px;z-index:1}.search-container-compact .sinput-compact{border-radius:25px;border:2px solid #ccc;padding:20px 12px 20px 40px;height:32px;width:100%;font:400 14px Lato;box-sizing:border-box;transition:border-color .3s ease}.search-container-compact .sinput-compact:focus{outline:none;border-color:#1b4ca1;box-shadow:0 0 0 2px #1b4ca11a}.search-container-compact .sinput-compact::placeholder{color:#999}.btn-group-compact{display:flex;gap:8px;flex:0 0 auto}.category-list-item{padding:8px 12px!important;border-radius:6px;border:1px solid transparent;transition:all .3s ease;background:#f8f9fa;color:#333;font-family:Lato;font-size:14px!important;font-weight:400!important}.category-list-item:hover{background:#1b4ca10d;border-color:#1b4ca133}.category-list-item.selected-theme{background:#1b4ca11a;border-color:#1b4ca1;color:#1b4ca1;font-weight:600!important}.category-list-item.selected-theme:before{content:\"\\2713  \";color:#1b4ca1;font-weight:700}.theme-filter-controls{margin-bottom:8px}.clear-filter-btn{background:#f8f9fa;border:1px solid #ddd;border-radius:20px;padding:4px 12px;font-size:12px;color:#666;cursor:pointer;transition:all .3s ease;display:flex;align-items:center;gap:4px}.clear-filter-btn:hover{background:#e9ecef;border-color:#adb5bd}.clear-filter-btn mat-icon{font-size:16px;width:16px;height:16px}.no-course-found-container{display:flex;justify-content:center;align-items:center;min-height:300px;padding:20px}.no-course-card{background:linear-gradient(135deg,#f8f9fa,#e9ecef);border:2px dashed #ced4da;border-radius:16px;padding:40px;text-align:center;max-width:500px;box-shadow:0 4px 12px #0000000d}.no-course-card .no-course-icon{margin-bottom:20px}.no-course-card .no-course-icon mat-icon{font-size:48px;width:48px;height:48px;color:#6c757d}.no-course-card .no-course-content h4{color:#495057;font-family:Montserrat;font-size:24px;font-weight:600;margin-bottom:12px}.no-course-card .no-course-content p{color:#6c757d;font-family:Lato;font-size:16px;line-height:1.5;margin-bottom:12px}.no-course-card .no-course-content p strong{color:#1b4ca1;font-weight:600}.no-course-card .suggest-course-btn{background:linear-gradient(135deg,#1b4ca1,#164080);color:#fff;border:none;border-radius:25px;padding:12px 24px;font-family:Lato;font-size:14px;font-weight:600;cursor:pointer;display:flex;align-items:center;gap:8px;margin:20px auto 0;transition:all .3s ease;box-shadow:0 4px 12px #1b4ca14d}.no-course-card .suggest-course-btn:hover{background:linear-gradient(135deg,#164080,#0f2f5f);transform:translateY(-2px);box-shadow:0 6px 16px #1b4ca166}.no-course-card .suggest-course-btn:active{transform:translateY(0)}.no-course-card .suggest-course-btn mat-icon{font-size:18px;width:18px;height:18px}.left-panel{flex:0 0 280px!important;background:#f8f9fa;border-radius:12px;padding:16px;border:1px solid #e9ecef;max-height:600px;overflow-y:auto;font-weight:400!important}@media (max-width: 1200px){.search-and-buttons-container{flex-direction:column;align-items:stretch}.search-container-compact{min-width:auto;width:100%}.btn-group-compact{justify-content:center;flex-wrap:wrap}}@media (max-width: 1200px) and (min-width: 769px){.course-list-item{flex:1 1 calc(50% - 10px);min-width:300px;max-width:none}}@media (max-width: 768px){.course-list-container-flex{flex-direction:column}.left-panel{flex:none!important;max-height:300px}.course-list-item{flex:0 0 100%;max-width:100%}.no-course-card{padding:20px}.no-course-card .no-course-content h4{font-size:20px}.no-course-card .no-course-content p{font-size:14px}}::ng-deep .error-snackbar{background-color:#f44336!important;color:#fff!important;font-weight:500}::ng-deep .error-snackbar .mat-simple-snackbar-action{color:#fff!important}::ng-deep .session-expired-snackbar{background-color:#ff9800!important;color:#fff!important;font-weight:600}::ng-deep .session-expired-snackbar .mat-simple-snackbar-action{color:#fff!important;font-weight:700}.download-pdf{justify-content:end;display:flex;flex-direction:row}.gap-analysis-pdf-container{font-family:Lato;max-width:900px;margin:auto;color:#212121}.gap-analysis-pdf-header{text-align:center;margin-bottom:2rem}.gap-analysis-pdf-header .logo{height:60px;margin-bottom:.5rem}.gap-analysis-pdf-header h1{font-size:1.8rem;font-weight:600;margin:.5rem 0}.gap-analysis-pdf-header .subtitle{color:#555;font-size:.95rem}.gap-analysis-pdf-header .download-btn{background:#5e00ff;color:#fff;border:none;padding:10px 20px;border-radius:6px;margin-top:1rem;font-weight:500;cursor:pointer}.competency-snapshot{background:#fafafa;border-radius:12px;padding:2rem;margin-bottom:2rem}.competency-snapshot h2{font-size:1.4rem;font-weight:600;margin-bottom:1.5rem}.competency-snapshot .snapshot-content{display:flex;gap:2rem;align-items:center;justify-content:space-between}.competency-snapshot .snapshot-content .circle-wrapper{position:relative;width:120px;height:120px}.competency-snapshot .snapshot-content .circle-wrapper .progress-ring-bg{fill:none;stroke:#eee;stroke-width:10}.competency-snapshot .snapshot-content .circle-wrapper .progress-ring-circle{fill:none;stroke:#6c63ff;stroke-width:10;stroke-linecap:round;stroke-dasharray:326.72;stroke-dashoffset:117.6192;transform:rotate(-90deg);transform-origin:center;transition:stroke-dashoffset .35s}.competency-snapshot .snapshot-content .circle-wrapper .percentage-text{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);font-weight:600;font-size:1.4rem;text-align:center}.competency-snapshot .snapshot-content .circle-wrapper .percentage-text span{display:block;font-size:.75rem;font-weight:400;color:#555}.competency-snapshot .snapshot-content .details{flex-grow:1}.competency-snapshot .snapshot-content .details .total-competencies{font-size:1.2rem;margin-bottom:1rem}.competency-snapshot .snapshot-content .details .bar{margin:.5rem 0;padding:.6rem 1rem;border-radius:6px;font-weight:500;display:flex;justify-content:space-between;color:#fff}.competency-snapshot .snapshot-content .details .bar.behavioral{background:#7b1fa2}.competency-snapshot .snapshot-content .details .bar.functional{background:#0288d1}.competency-snapshot .snapshot-content .details .bar.domain{background:#f57c00}.gap-section{margin-top:2rem}.gap-section h2{font-size:1.3rem;margin-bottom:1rem}.gap-section .gap-box{background:#eef1ff;border-left:5px solid #6c63ff;padding:1rem;border-radius:6px;font-weight:500;color:#333}.gap-section .green-bg{background-color:#0080001c;border-left:5px solid #2d9b2d;padding:1rem;border-radius:6px;font-weight:500;color:#006400}.competency-container{width:100%;margin:0 auto;font-family:Segoe UI,sans-serif;color:#212121;display:flex;flex-direction:column}.total-box{background:#f8f9fc;border-radius:10px;padding:1.5rem;text-align:center;border:1px solid #e0e0e0;margin-bottom:1.5rem}.total-box .title{font-size:1rem;color:#666}.total-box .count{font-size:2rem;font-weight:700;color:#111;margin-top:.5rem}.progress-group{margin-bottom:1.5rem}.progress-group .progress-label{display:flex;justify-content:space-between;margin-bottom:6px}.progress-group .progress-label .label-text{font-weight:600}.progress-group .progress-label .covered-text{font-size:.9rem;color:#444}.progress-group .progress-label .behavioral{color:#f8b861}.progress-group .progress-label .functional{color:#e24577}.progress-group .progress-label .domain{color:#7b47a4}.progress-group .progress-bar{height:10px;background-color:#e0e0e0;border-radius:5px;overflow:hidden}.progress-group .progress-bar .progress-fill{height:100%;border-radius:5px;transition:width .5s ease-in-out}.progress-group .progress-bar .progress-fill.behavioral{background:#f8b861}.progress-group .progress-bar .progress-fill.functional{background:#e24577}.progress-group .progress-bar .progress-fill.domain{background:#7b47a4}.competency-card{border-radius:8px;padding:1rem 1.5rem;margin-bottom:1rem;border:1px solid transparent}.competency-card .title{font-weight:600;font-size:1.1rem;color:#222;margin-bottom:.4rem}.competency-card .subtitle{font-size:.95rem;color:#555}.competency-card .subtitle .tag{font-weight:500}.competency-card .subtitle .behavioral,.competency-card .subtitle .domain,.competency-card .subtitle .functional{color:#000}.competency-card.behavioral{background:linear-gradient(0deg,#f8b86152 0% 100%),#fff;border-color:#f8b861}.competency-card.functional{background:linear-gradient(0deg,#e245773d 0% 100%),#fff;border-color:#e24577}.competency-card.domain{background:linear-gradient(0deg,#7b47a43d 0% 100%),#fff;border-color:#7b47a4}.disclaimer-container{margin:8px 16px 0}.disclaimer-message{background-color:#fff3cd;border:1px solid #ffeaa7;border-radius:20px;padding:8px 16px;font-family:Lato;font-size:14px;color:#333;line-height:1.2}.disclaimer-message strong{color:#000;font-weight:600}.select-all-container{display:flex;flex-direction:row;justify-content:space-between}:host ::ng-deep .search-and-buttons-container .mat-form-field-infix{padding:10px!important}:host ::ng-deep .search-and-buttons-container .mat-form-field-wrapper{width:100%!important}:host ::ng-deep .select-search-panel{border:1px solid #ccc!important;border-radius:12px!important;box-shadow:0 8px 20px #0000001f}:host ::ng-deep .mat-select-arrow-wrapper{margin-top:5px!important}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline{color:#ccc}:host ::ng-deep .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#1b4ca1;border-color:#1b4ca1!important}:host ::ng-deep .select-search-panel .mat-option.mat-selected:not(.mat-option-disabled){background-color:#1b4ca1!important;color:#fff!important}:host ::ng-deep .mat-form-field-appearance-outline{border-radius:25px;border:1px solid #ccc}:host ::ng-deep .mat-form-field-focused .mat-form-field-appearance-outline{border-color:#1b4ca1!important}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:25px 0 0 25px;border:none!important}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline-end{border-right:none!important;border:none!important;border-radius:0 25px 25px 0}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline-gap{border:none!important;border-radius:25px}:host::ng-deep .mat-form-field-appearance-outline .mat-form-field-infix{background-color:transparent!important}:host ::ng-deep .search-and-buttons-container .mat-option-text{color:#fff!important}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i5.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i5.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "directive", type: i4.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i6.MatLegacyFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i6.MatLegacyLabel, selector: "mat-label" }, { kind: "directive", type: i7.MatLegacyInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", exportAs: ["matInput"] }, { kind: "component", type: i8.MatLegacyButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i9.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i10.MatLegacySelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { kind: "component", type: i11.MatLegacyOption, selector: "mat-option", exportAs: ["matOption"] }, { kind: "component", type: i12.MatLegacyCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "directive", type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i4.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i13.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "component", type: i14.MatTab, selector: "mat-tab", inputs: ["disabled"], exportAs: ["matTab"] }, { kind: "component", type: i14.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "disableRipple", "fitInkBarToContent", "mat-stretch-tabs"], exportAs: ["matTabGroup"] }, { kind: "component", type: i15.GapAnalysisRecommendedCourseComponent, selector: "app-gap-analysis-recommended-course", inputs: ["planData"] }, { kind: "pipe", type: i5.TitleCasePipe, name: "titlecase" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GenerateCourseRecommendationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-generate-course-recommendation', template: "<div class=\"view-cbp-plan\">\n    <div class=\"popup-container\">\n        \n        <!-- Initial Loading Screen (for initial load and regeneration) -->\n        <div class=\"initial-loading-container\" *ngIf=\"!dataLoaded || isRegeneratingWithProgress\">\n            <div class=\"loading-content\">\n                <mat-spinner diameter=\"50\"></mat-spinner>\n                <div class=\"loading-text mt-3\">\n                    <p class=\"main-message\">{{ currentProcessingStage || (isRegeneratingWithProgress ? 'Regenerating course recommendations...' : 'Loading course recommendations...') }}</p>\n                    <div class=\"progress-details\" *ngIf=\"progressPercentage > 0\">\n                        <div class=\"progress-indicator\">\n                            <div class=\"progress-bar-container\">\n                                <div class=\"progress-bar\" \n                                     [style.width.%]=\"progressPercentage\">\n                                </div>\n                            </div>\n                            <small class=\"progress-text\">{{ progressPercentage }}% Complete</small>\n                        </div>\n                        <small class=\"time-estimate\">\n                            Real-time course generation in progress. This may take 1-2 minutes.\n                        </small>\n                    </div>\n                </div>\n            </div>\n        </div>\n\n        <!-- Main Content -->\n        <div class=\"main-content\" *ngIf=\"dataLoaded && !isRegeneratingWithProgress\">\n        <div class=\"popup-header\">\n            <div class=\"header-left\">\n                <div class=\"heading\">Save Courses (<span>{{sharedService?.cbpPlanFinalObj?.ministry?.orgName}} <span\n                            *ngIf=\"planData?.designation_name \">/ {{planData?.designation_name}}</span></span>)</div>\n            </div>\n            <div class=\"header-actions\">\n                <button class=\"regenerate-btn\" (click)=\"regenerateCourseRecommendations()\"\n                        [disabled]=\"isRegenerating\"\n                        mat-raised-button color=\"primary\">\n                    <mat-icon *ngIf=\"!isRegenerating\">refresh</mat-icon>\n                    <mat-spinner *ngIf=\"isRegenerating\" diameter=\"20\"></mat-spinner>\n                    <span>{{isRegenerating ? 'Regenerating...' : 'Regenerate Recommendations'}}</span>\n                </button>\n                <div class=\"cursor-pointer close-btn\" (click)=\"closeDialog()\">\n                    <mat-icon>close</mat-icon>\n                </div>\n            </div>\n        </div>\n        <div class=\"section-container mt-4\">\n            <mat-tab-group (selectedTabChange)=\"onOuterTabChange($event)\">\n                <!-- First Main Tab -->\n                <mat-tab label=\"course recommendation\">\n                    <!-- Nested Tabs -->\n                    <!-- <mat-tab-group (selectedTabChange)=\"onInnerTabChange($event)\">\n                        <mat-tab label=\"all\">\n\n                        </mat-tab>\n                        <mat-tab label=\"behavioural\">\n\n                        </mat-tab>\n                        <mat-tab label=\"functional\">\n\n                        </mat-tab>\n                        <mat-tab label=\"domain\">\n\n                        </mat-tab>\n                    </mat-tab-group> -->\n                </mat-tab>\n\n                <!-- Second Main Tab -->\n                <mat-tab label=\"gap analysis\">\n                    <!-- <p>Gap analysis content goes here</p> -->\n                </mat-tab>\n            </mat-tab-group>\n            <form [formGroup]=\"filterForm\" class=\"filters-container\">\n            <div class=\"role-mapping-container\"\n                *ngIf=\"outerTabActiveIndex === 0 && (innerTabActiveIndex === 0 || innerTabActiveIndex === 1 || innerTabActiveIndex === 2 || innerTabActiveIndex === 3 )\">\n                <div class=\"container\">\n                    <div class=\"section-header-improved mt-3\">\n                        <div class=\"search-and-buttons-container\">\n                            <div>\n                                <label>Search Courses</label>\n                            </div>                            \n                            <div class=\"search-container-compact\">\n                                <div class=\"rsearch\">\n                                    <mat-icon class=\"search-icon\">search</mat-icon>\n                                    <input class=\"sinput-compact\" [(ngModel)]=\"searchText\"\n                                           (input)=\"applyFilter($event.target.value);\"\n                                           placeholder=\"Search Courses\" type=\"text\">\n                                </div>\n                            </div>\n                            \n                        </div>\n                        \n\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Competency</label>\n                            </div>   \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.competency?.length ? '' : 'Competency' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"competency\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                        \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Competency\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'competency')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredCompetency\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>                       \n                            \n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Rating</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.rating?.length ? '' : 'Rating' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"rating\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Reatings\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'rating')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredRatings\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                       \n                      \n                        \n                        \n                    </div>\n                    <div class=\"section-header-improved-sec-2 mt-4\">\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Language</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.language?.length ? '' : 'Language' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"language\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Languages\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'language')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredLanguages\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Duration</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.duration?.length ? '' : 'Duration' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"duration\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Duration\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'duration')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredDurations\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Provider</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.provider?.length ? '' : 'Provider' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"provider\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Provider\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'provider')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredProviders\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div style=\"margin-top: 45px;margin-left: 20px;\">\n                            <input class=\"btn-active\" type=\"button\" value=\"Reset All Filters\"\n                                (click)=\"resetFilters()\" />\n                        </div>\n                    </div>\n                    <div class=\"mt-4\">\n                        <div style=\"font-size:16px;font-weight:bold;color:#000\">\n                            Filtered Course Count : {{filterdCourses?.length}}\n                        </div>\n                    </div>\n                    <div class=\"mt-5 sub-heading select-all-container\" *ngIf=\"filterdCourses?.length\">\n                        <div style=\"margin-left: 16px;\">\n                            <mat-checkbox [checked]=\"false\" (change)=\"selectAllCourses($event)\">Select All\n                                Courses</mat-checkbox>\n                        </div>\n                        <div class=\"btn-group-compact\">\n                            <div>\n                                <input class=\"btn-active\" type=\"button\" value=\"Suggest More Course From iGOT\"\n                                    (click)=\"suggestMoreCourses()\" />\n                            </div>\n                            <div class=\"pl-2\">\n                                <input [disabled]=\"selectFilterCourses?.length > 0 ? false : true\"\n                                    [ngClass]=\"selectFilterCourses?.length > 0 ? 'btn-active' : 'btn-disable'\"\n                                    type=\"button\" [value]=\"mode === 'add' ? 'Save Courses' : 'Update Courses'\"\n                                    (click)=\"saveCourses()\" />\n                            </div>\n                        </div>\n                    </div>\n                    <div class=\"disclaimer-container mt-2\" *ngIf=\"filterdCourses?.length\">\n                        <div class=\"disclaimer-message mt-4\">\n                            <strong>Disclaimer:</strong> Please verify the public course URL before adding it to the plan.\n                        </div>\n                    </div>\n                    <div class=\"mt-2\">\n\n                        <div class=\"course-list-container\">\n                            <div\n                                [ngClass]=\"innerTabActiveIndex > 0 ? 'course-list-container-flex':'course-list-container-right-flex' \">\n                                <div *ngIf=\"innerTabActiveIndex > 0\"\n                                    [ngClass]=\"innerTabActiveIndex > 0 ? 'left-panel':''\">\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 1\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Behavioural</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                             class=\"category-list-item cursor-pointer mt-2\"\n                                             [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                             *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 2\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Functional</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                             class=\"category-list-item cursor-pointer mt-2\"\n                                             [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                             *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 3\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Domain</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                            class=\"category-list-item cursor-pointer mt-2\"\n                                            [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                            *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                </div>\n                                <div [ngClass]=\"innerTabActiveIndex > 0 ? 'right-panel':'right-panel-flex'\">\n                                    <!-- No Course Found Message in Right Panel -->\n                                    <div class=\"no-course-found-container\"\n                                        *ngIf=\"filterdCourses?.length === 0 && selectedThemeFilter\">\n                                        <div class=\"no-course-card\">\n                                            <div class=\"no-course-icon\">\n                                                <mat-icon>search_off</mat-icon>\n                                            </div>\n                                            <div class=\"no-course-content\">\n                                                <h4>No Courses Found</h4>\n                                                <p>No courses found for the selected theme:\n                                                    <strong>{{selectedThemeFilter}}</strong></p>\n                                                <p>Would you like to add a course for this competency?</p>\n                                                <button class=\"suggest-course-btn\"\n                                                    (click)=\"addCourseForSelectedTheme()\">\n                                                    <mat-icon>add_circle</mat-icon>\n                                                    Add Course\n                                                </button>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <!-- Courses List -->\n                                    <div class=\"course-list-item\" *ngFor=\"let item of filterdCourses;let i=index\">\n\n                                        <div class=\"course-content\">\n                                            <div class=\"course-header\">\n                                                <div class=\"checked-course-container\">\n                                                    <div>\n                                                        <mat-checkbox [checked]=\"checkIfCourseExists(item)\"\n                                                            (change)=\"selectedFilterCourses($event, item)\"></mat-checkbox>\n                                                    </div>\n                                                    <div class=\"ml-2\">\n                                                        <div class=\"course-pill-container\">\n                                                            <div class=\"course-pill\">\n                                                                <div class=\"course-pill-text\">\n                                                                    <span><img\n                                                                            src=\"assets/icons/course.svg\"></span>&nbsp;<span>Course</span>\n                                                                </div>\n                                                            </div>\n                                                        </div>\n                                                    </div>\n\n                                                </div>\n\n                                                <!-- <div>\n                                        <div class=\"ai-recommened-pill\">\n                                            <div class=\"ai-recommened-pill-text\">\n                                                <span class=\"ai-loader-icon\"><img src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                <span *ngIf=\"item?.rationale\">AI Recommended\n                                                    <span *ngIf=\"item?.is_public\"> - Public</span>\n                                                    <span *ngIf=\"!item?.is_public\"> - iGOT</span>\n                                                </span>\n                                                <span *ngIf=\"!item?.rationale\">Manually Suggested - iGOT</span>\n\n                                            </div>\n                                        </div>\n                                    </div> -->\n                                                <div *ngIf=\"item?.rationale && !item?.is_public\">\n                                                    <div class=\"ai-recommened-pill-green\">\n                                                        <div class=\"ai-recommened-pill-green-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>AI Recommended - iGOT </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n                                                <div *ngIf=\"item?.rationale && item?.is_public\">\n                                                    <div class=\"ai-recommened-pill-public\">\n                                                        <div class=\"ai-recommened-pill-public-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>AI Recommended - Public </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n                                                <div *ngIf=\"!item?.rationale\">\n                                                    <div class=\"ai-recommened-pill-gray\">\n                                                        <div class=\"ai-recommened-pill-gray-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>Manually Suggested - iGOT </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n\n                                            </div>\n                                            <div class=\"course-title mt-3 cursor-pointer\" (click)=\"redirectToToc(item)\">\n                                                <span *ngIf=\"item?.course\">{{item?.course}}</span>\n                                                <!-- <span *ngIf=\"item?.name\">{{item?.name}}****</span> -->\n                                                <span style=\"margin-left:10px;\" (click)=\"redirectToToc(item)\"><img\n                                                        height=\"18px\" width=\"18px\"\n                                                        src=\"assets/icons/redirect.png\" /></span>\n                                            </div>\n                                            <div class=\"course-desc mt-2\">\n                                                <!-- <span *ngIf=\"item?.rationale\">{{item?.rationale}}</span> -->\n                                                <span *ngIf=\"item?.description\">{{item?.description}}</span>\n                                            </div>\n                                            <div class=\"mt-3\" *ngIf=\"getCompetenciesByType('Behavioural',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Behavioural Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"behavioural-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Behavioural',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Behavioural',i)\"\n                                                        class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Behavioural',i)\">\n                                                            {{ isExpanded('Behavioural',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Behavioural',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n                                            <div class=\"mt-2\" *ngIf=\"getCompetenciesByType('Functional',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Functional Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"functional-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Functional',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Functional',i)\"\n                                                        class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Functional',i)\">\n                                                            {{ isExpanded('Functional',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Functional',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n                                            <div class=\"mt-2\" *ngIf=\"getCompetenciesByType('Domain',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Domain Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"domain-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Domain',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Domain',i)\" class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Domain',i)\">\n                                                            {{ isExpanded('Domain',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Domain',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n\n\n                                        </div>\n\n                                        <!-- Relevancy and Duration section -->\n                                        <div class=\"course-footer\" *ngIf=\"item?.relevancy\">\n                                            <div class=\"relevancy-pill-green\">\n                                                <div class=\"relevancy-container\">\n                                                    <div class=\"relevancy\">Relevancy</div>\n                                                    <div class=\"dash\">-</div>\n                                                    <div class=\"percentage\">{{item?.relevancy}}%</div>\n                                                </div>\n                                            </div>\n                                            <div class=\"relevancy-pill-green\">\n                                                <div class=\"relevancy-container\">\n                                                    <div class=\"relevancy\">Duration</div>\n                                                    <div class=\"dash\">-</div>\n                                                    <div class=\"percentage\">\n                                                        <span\n                                                            *ngIf=\"item?.duration\">{{getDuration(item?.duration)}}</span>\n                                                        <span *ngIf=\"!(item?.duration)\">N/A</span>\n                                                    </div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                    </div>\n                                </div>\n                            </div>\n                        </div>\n                    </div>\n\n                    <!-- General No Data Message (only when no theme filter is active) -->\n                    <div class=\"mt-2 sub-heading\" *ngIf=\"filterdCourses?.length === 0 && !selectedThemeFilter\">\n                        <p>No Data Found</p>\n                    </div>\n                </div>\n            </div>\n        </form>\n            <div class=\"role-mapping-container\" *ngIf=\"outerTabActiveIndex === 1\">\n                <div id=\"gap-analysis-content\">\n\n                    <div class=\"download-pdf mt-4 mb-2\">\n                        <div>\n                            <input class=\"btn-active\" type=\"button\" value=\"Download\" (click)=\"downloadPDF()\" />\n                        </div>\n                    </div>\n                    <div>\n                        <!-- <div *ngIf=\"isPDFDownload\">\n                            <div class=\"pdf-heading\">{{sharedService?.cbpPlanFinalObj?.ministry?.name}} <span\n                                    *ngIf=\"planData?.designation_name \">_{{planData?.designation_name}}_Gap_Analysis</span>\n                            </div>\n                        </div> -->\n                        <div class=\"d-flex vh-100\" [ngClass]=\"isPDFDownload ? 'mt-4':''\">\n                            <!-- Sidebar -->\n                            <div class=\"d-flex flex-column p-3 bg-light border-end\" style=\"width: 250px;\">\n                                <h5 class=\"mb-4\">Analyze by Category</h5>\n                                <button *ngFor=\"let item of menuItems\"\n                                    class=\"btn btn-outline-primary mb-2 text-start menu-list-item\"\n                                    [class.active]=\"selectedCategory === item.key\" (click)=\"selectCategory(item.key)\">\n                                    {{ item.label }}\n                                </button>\n                            </div>\n\n                            <!-- Main Content -->\n                            <div class=\"flex-grow-1 p-4\">\n                                <div class=\"d-flex justify-content-between gap-3 \">\n                                    <div class=\"p-3 gray-bg\">\n                                        <div class=\"div-label sub-heading\">\n                                            <p>Competencies Covered</p>\n                                        </div>\n                                        <div class=\"div-count\">{{competencyCoveredCount}}</div>\n                                    </div>\n                                    <div class=\"p-3 gray-bg\">\n                                        <div class=\"div-label sub-heading\">\n                                            <p *ngIf=\"selectedCategory === 'all'\">Total Competencies</p>\n                                            <p *ngIf=\"selectedCategory === 'behavioral'\">Total Behavioural Competencies\n                                            </p>\n                                            <p *ngIf=\"selectedCategory === 'functional'\">Total Functional Competencies\n                                            </p>\n                                            <p *ngIf=\"selectedCategory === 'domain'\">Total Domain Competencies</p>\n                                        </div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'all'\">\n                                            {{this.planData?.competencies?.length}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            {{behavioralTotalCompetencies}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'functional'\">\n                                            {{functionalTotalCompetencies}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'domain'\">\n                                            {{domainTotalCompetencies}}</div>\n                                    </div>\n                                    <div class=\"p-3 green-bg\">\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'all'\">Overall Coverage\n                                        </div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            Behavioural Coverage</div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'functional'\">\n                                            Functional Coverage</div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'domain'\">Domain\n                                            Coverage</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'all'\">\n                                            {{overallCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            {{behavioralCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'functional'\">\n                                            {{functionalCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'domain'\">\n                                            {{domainCoverage}}</div>\n                                    </div>\n                                </div>\n                                <div class=\"mt-4 all-category-list\" [ngSwitch]=\"selectedCategory\">\n                                    <div *ngSwitchCase=\"'all'\">\n                                        <h4>All Categories</h4>\n\n                                        <!-- Show Behavioural section only if there are unmatched behavioural competencies -->\n                                        <div class=\"mt-4\"\n                                            *ngIf=\"behaviouralNotMatched && behaviouralNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Behavioural</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of behaviouralNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Behavioral')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show Functional section only if there are unmatched functional competencies -->\n                                        <div class=\"mt-4\"\n                                            *ngIf=\"functionalNotMatched && functionalNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Functional</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of functionalNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Functional')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show Domain section only if there are unmatched domain competencies -->\n                                        <div class=\"mt-4\" *ngIf=\"domainNotMatched && domainNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Domain</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of domainNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Domain')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show message when all competencies are covered -->\n                                        <div class=\"mt-4 text-center\"\n                                            *ngIf=\"(!behaviouralNotMatched || behaviouralNotMatched.length === 0) && \n                                                                           (!functionalNotMatched || functionalNotMatched.length === 0) && \n                                                                           (!domainNotMatched || domainNotMatched.length === 0)\">\n                                            <div class=\"no-gaps-message\">\n                                                <mat-icon class=\"success-icon\">check_circle</mat-icon>\n                                                <h4>Excellent! All competencies are covered</h4>\n                                                <p>All required competencies have been addressed by the selected\n                                                    courses.</p>\n                                            </div>\n                                        </div>\n\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'behavioral'\">\n                                        <h4>Behavioural</h4>\n                                        <div class=\"mt-4\" *ngIf=\"behavioralCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Behavioural</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of behaviouralNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Behavioral')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course </span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"behavioralCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    \uD83C\uDF89 Excellent! All behavioral competencies are covered by the\n                                                    selected courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'functional'\">\n                                        <h4>Functional</h4>\n                                        <div class=\"mt-4\" *ngIf=\"functionalCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Functional</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of functionalNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Functional')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"functionalCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    \uD83C\uDF89 Excellent! All functional competencies are covered by the\n                                                    selected courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'domain'\">\n                                        <h4>Domain</h4>\n                                        <div class=\"mt-4\" *ngIf=\"domainCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Domain</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of domainNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Domain')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course </span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"domainCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    \uD83C\uDF89 Excellent! All domain competencies are covered by the selected\n                                                    courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchDefault>\n                                        <p>Please select a category.</p>\n                                    </div>\n                                </div>\n                            </div>\n                        </div>\n                    </div>\n                </div>\n\n            </div>\n        </div>\n        </div> <!-- Close main-content div -->\n\n    </div>\n</div>\n\n\n<div [hidden]=\"!isPDFDownload\" class=\"gap-analysis-pdf-container\" #pdfContent>\n    <div class=\"gap-analysis-pdf-header\">\n      <img src=\"assets/icons/karmayogiLogo-min.png\" alt=\"Karmayogi Bharat Logo\" class=\"logo\" />\n      <h1><span>\n        <span *ngIf=\"sharedService?.cbpPlanFinalObj?.ministry?.sbOrgType === 'state'\">{{sharedService?.cbpPlanFinalObj?.department_name?.name}}</span> \n        <span *ngIf=\"sharedService?.cbpPlanFinalObj?.ministry?.sbOrgType === 'ministry'\">{{sharedService?.cbpPlanFinalObj?.ministry?.name}}</span>   \n        <span *ngIf=\"planData?.designation_name \">/ {{planData?.designation_name}}</span>\n        </span></h1>\n      <p class=\"subtitle\">A detailed breakdown of competencies Gap Analysis</p>\n     \n    </div>\n  \n    <div class=\"competency-snapshot\">\n      <h2>Competency Snapshot</h2>\n      <div class=\"snapshot-content\">\n        <div class=\"circle-wrapper\">\n          <svg class=\"progress-ring\" width=\"120\" height=\"120\">\n            <circle class=\"progress-ring-bg\" cx=\"60\" cy=\"60\" r=\"52\" />\n            <circle class=\"progress-ring-circle\" cx=\"60\" cy=\"60\" r=\"52\" />\n          </svg>\n          <div class=\"percentage-text\">{{overallCoverage}}<br /><span>Overall Coverage</span></div>\n        </div>\n  \n        <div class=\"competency-container\">\n            <!-- Total Competencies Box -->\n            <div class=\"total-box\">\n              <div class=\"title\">Total Competencies</div>\n              <div class=\"count\">{{this.planData?.competencies?.length}}</div>\n            </div>\n          \n            <!-- Progress Bars -->\n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text behavioral\">Behavioural</span>\n                <span class=\"covered-text\">{{behavioralCompetencyCoveredCount}} / {{behavioralTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill behavioral\" [style.width.%]=\"(behavioralCompetencyCoveredCount / behavioralTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          \n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text functional\">Functional</span>\n                <span class=\"covered-text\">{{functionalCompetencyCoveredCount}} / {{functionalTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill functional\" [style.width.%]=\"(functionalCompetencyCoveredCount / functionalTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          \n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text domain\">Domain</span>\n                <span class=\"covered-text\">{{domainCompetencyCoveredCount}} / {{domainTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill domain\" [style.width.%]=\"(domainCompetencyCoveredCount / domainTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          </div>\n      </div>\n    </div>\n  \n    <div class=\"gap-section mb-4\">\n      <h2>Detailed Competency Analysis</h2>\n      <div class=\"gap-box\">\n        Bridge Your Competencies Gap\n        <p class=\"subtitle\">Here are {{this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)}} key areas for development.</p>\n    </div>\n    </div>\n    <div class=\"sub-heading mb-4\">\n        <p>Gap to Address <span *ngIf=\"(this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)) > 0\">({{this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)}})</span></p>\n        \n    </div>\n    <div class=\"competency-card behavioral\" *ngFor=\"let item of behaviouralNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n          &nbsp; \u2022 &nbsp;\n          <span class=\"tag behavioral\">Behavioural</span>\n        </div>\n    </div>\n      \n      <div class=\"competency-card functional\" *ngFor=\"let item of functionalNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n           &nbsp; \u2022 &nbsp;\n          <span class=\"tag functional\">Functional</span>\n        </div>\n      </div>\n      \n      <div class=\"competency-card domain\" *ngFor=\"let item of domainNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n          <!-- Project Management  -->\n          &nbsp; \u2022 &nbsp;\n          <span class=\"tag domain\">Domain</span>\n        </div>\n      </div>\n      <div class=\"sub-heading mb-4\">\n        <p>Covered Competencies <span>({{this.planData?.competencies?.length - (behaviouralNotMatched?.length + functionalNotMatched?.length + domainNotMatched?.length)}})</span></p>        \n     </div>\n     <div class=\"gap-section mb-4\">\n        \n        <div class=\"green-bg\">\n            <div class=\"div-green-label mb-2\">\n                Congratulations!\n            </div>            \n            <p>You have successfully covered </p>\n          <p class=\"subtitle\">{{this.planData?.competencies?.length - (behaviouralNotMatched?.length + functionalNotMatched?.length + domainNotMatched?.length)}} key competencies, forming a strong professional foundation.</p>\n      </div>\n      </div>\n      <div class=\"competency-card behavioral\" *ngFor=\"let item of behaviouralMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n          {{item?.sub_theme}}&nbsp; \u2022 &nbsp;\n          <span class=\"tag behavioral\">Behavioural</span>\n        </div>\n    </div>\n      \n      <div class=\"competency-card functional\" *ngFor=\"let item of functionalMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n            {{item?.sub_theme}}&nbsp; \u2022 &nbsp;\n          <span class=\"tag functional\">Functional</span>\n        </div>\n      </div>\n      \n      <div class=\"competency-card domain\" *ngFor=\"let item of domainMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n          <!-- Project Management  -->\n          {{item?.sub_theme}}&nbsp; \u2022 &nbsp;\n          <span class=\"tag domain\">Domain</span>\n        </div>\n      </div>\n      <div class=\"gap-section mb-4\">\n        <h2>Recommended Courses</h2>\n      </div>\n      <app-gap-analysis-recommended-course [planData]=\"planData\"></app-gap-analysis-recommended-course>\n</div>\n  \n\n\n<div class=\"overlay-loader\" *ngIf=\"loading && dataLoaded && !isRegeneratingWithProgress\">\n    <div class=\"loading-content\">\n        <mat-spinner diameter=\"50\"></mat-spinner>\n        <div class=\"loading-text mt-3\">\n            <p class=\"main-message\">{{ currentProcessingStage || 'Preparing course recommendation generation...' }}</p>\n            <div class=\"progress-details\">\n                <div class=\"progress-indicator\" *ngIf=\"progressPercentage > 0\">\n                    <div class=\"progress-bar-container\">\n                        <div class=\"progress-bar\" \n                             [style.width.%]=\"progressPercentage\">\n                        </div>\n                    </div>\n                    <small class=\"progress-text\">{{ progressPercentage }}% Complete</small>\n                </div>\n                <small class=\"time-estimate\">\n                    Real-time course generation in progress. This may take 1-2 minutes.\n                </small>\n            </div>\n        </div>\n    </div>\n</div>", styles: ["@charset \"UTF-8\";.container{margin:10px auto}.sub-heading p{color:#000;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal}.radio-label{color:#000;font-family:Lato;font-size:16px;font-style:normal;font-weight:400;line-height:normal}.radio-btn-group{display:flex;width:32px;height:32px;padding:2px;gap:10px}.label{color:var(--Body-Text-Body-Color, #212529);font-family:Lato;font-size:16px;font-style:normal;font-weight:700;line-height:150%}::ng-deep mat-form-field{background-color:#fff!important;border-radius:25px!important;padding-left:12px;padding-right:12px;height:42px;width:100%}::ng-deep mat-select{border-radius:25px!important;background-color:#fff!important}::ng-deep .mat-select-panel{background-color:#fff!important}::ng-deep .mat-select-panel .mat-option{border-radius:0!important}::ng-deep mat-form-field .mat-form-field-underline{display:none!important}::ng-deep mat-select .mat-select-placeholder{color:#0006;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal}::ng-deep mat-select .mat-select-value-text{color:#000;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal;line-height:normal!important;padding-top:0!important;padding-bottom:0!important}::ng-deep mat-select .mat-select-value{display:flex!important;align-items:center!important;height:100%!important}.additional-details textarea{display:flex;padding:16px 16px 0;flex-direction:column;align-items:flex-start;gap:10px;flex:1 0 0;align-self:stretch;width:100%;color:#000;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal;resize:none}.section-header{display:flex;flex-direction:row;align-items:center;justify-content:space-between}.btn-disable{border-radius:var(--Radius-Full-Round, 9999999px);opacity:.4;background:var(--Primary-KB-Primary-Light, #1B4CA1);color:var(--white-kb-white-100, #FFF);text-align:center;font-family:Lato;font-size:14px;font-style:normal;font-weight:700;line-height:normal;display:flex;height:32px;padding:0 16px;justify-content:center;align-items:center;gap:8px;border:none}.btn-group{display:flex;flex-direction:row;justify-content:space-between}.pl-2{padding-left:5px}.search-filter-section{display:flex;flex-direction:row;justify-content:space-between}.search .rsearch{position:relative}.search .search-icon{position:absolute;top:15px;font-size:20px;left:10px}.search .sinput{border-radius:32px;border:1px solid #d5d0d0;padding:15px 36px;font:400 14px Lato;width:800px}.select-map-route-container{display:flex;flex-direction:row}.selected-mapping-route p{color:#1b4ca1;font-family:Lato;font-size:20px;font-style:normal;font-weight:400;line-height:normal;text-decoration-line:underline;text-decoration-style:solid;-webkit-text-decoration-skip:ink;text-decoration-skip-ink:auto;text-decoration-thickness:auto;text-underline-offset:auto;text-underline-position:from-font}.edit-plan{display:flex;padding:4px;justify-content:center;align-items:center;gap:8px;border-radius:4px;background:#1b4ca129;color:#1b4ca1;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal;margin-left:10px}.search-container{display:flex;flex-direction:row}.course-container{display:flex;width:100%;padding:16px;flex-direction:column;align-items:flex-start;gap:24px;grid-row:2/span 1;grid-column:1/span 1;border-radius:12px;border:1px solid var(--borders-black-border-16-black, rgba(0, 0, 0, .16));background:#fff}.course-header{display:flex;flex-direction:row;justify-content:space-between;align-items:flex-start;width:100%;gap:8px}.course-pill{display:flex;height:24px;padding:8px;align-items:center;gap:4px;border-radius:16px;border:1px solid var(--borders-border-fill-focussed-4-light-100, #EF951E);background:#fefaf4}.ai-recommened-pill-green{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#0080001c}.ai-recommened-pill-green-text{color:#006400;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-public{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#1b4ca129}.ai-recommened-pill-public-text{color:#1b4ca1;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-gray{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#d3d3d3}.ai-recommened-pill-gray-text{color:#000;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-orange{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);background:#ffa50052}.ai-recommened-pill-orange-text{color:#5a3f0d;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.ai-recommened-pill-orange-text a{color:#5a3f0d!important;font-family:Lato;font-size:11px;font-style:normal;font-weight:600;line-height:normal}.igot-platform-pill{display:flex;padding:4px 8px;align-items:center;gap:8px;border-radius:var(--Radius-4, 4px);border:1px solid #EF951E;background:#ef951e29}.course-title{color:var(--Primary-KB-Primary-Light, #1B4CA1);font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:22px}.course-desc{color:#0009;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:1.4;display:-webkit-box;-webkit-line-clamp:3;-webkit-box-orient:vertical;overflow:hidden;text-overflow:ellipsis}.relevancy,.competencies-matched{color:#6c757d;font-family:Lato;font-size:12px;font-style:normal;font-weight:500;line-height:normal;align-items:center}.percentage{color:#1b4ca1;font-family:Lato;font-size:14px;font-style:normal;font-weight:600;line-height:normal}.relevancy-container,.competencies-matched-container{display:flex;flex-direction:row;align-items:center}.dash{padding:0 5px}::ng-deep .mat-radio-checked .mat-radio-inner-circle{background:#1b4ca1!important}.course-list-container{display:flex;flex-wrap:wrap;gap:16px;width:100%;padding:1rem}.course-list-item{flex:1 1 calc(50% - 10px);min-width:350px;max-width:500px;box-sizing:border-box;border:1px solid #e0e0e0;padding:16px;background-color:#fff;border-radius:12px;min-height:auto;box-shadow:0 2px 4px #0000001a;transition:box-shadow .2s ease;display:flex;flex-direction:column}.course-list-item:hover{box-shadow:0 4px 8px #00000026}.course-list-item:only-child{flex:1 1 auto;max-width:800px}.checked-course-container{display:flex;width:60%}.ml-2{margin-left:8px}::ng-deep .mat-checkbox-checked .mat-checkbox-background{background:#1b4ca1!important}.igot-platform-pill-text{color:#1b4ca1;font-family:Lato;font-size:12px;font-style:normal;font-weight:700;line-height:normal}.course-pill-text{color:var(--accessbility-shades-without-opacity-kb-greys-black-87, #212121);text-align:center;font-family:Poppins;font-size:12px;font-style:normal;font-weight:400;line-height:normal}.ai-loader-icon img,.igot-platform-icon img{width:15.714px;height:15.714px;flex-shrink:0}.competency-container{display:flex;justify-content:space-between;flex-direction:row}.outside-layer-total{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #1B4CA1;background:#edf1f8;width:132px}.outside-layer-functional{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #E24577;background:#f8d2de;width:132px}.outside-layer-domain{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #7B47A4;background:#dfd3e9;width:132px}.outside-layer-behavioral{display:flex;padding:4px 12px;justify-content:center;align-items:center;gap:16px;border-radius:12px 4px 4px 12px;border-left:2px solid #F8B861;background:#fde8cc;width:132px}.inside-layer{color:#1b4ca1;font-family:Lato;font-size:12px;font-style:normal;font-weight:400;line-height:normal}.count{color:#1b4ca1;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal}.suggest-courses-header{display:flex;flex-direction:row;justify-content:space-between}.suggest-course-control{display:flex;flex-direction:row}.course-card-container{width:172px;border-radius:3.307px;border:.827px solid var(--borders-border-8-black, rgba(0, 0, 0, .08));background-color:#fff}.highlight-ai{font-family:Montserrat;font-size:24px;font-style:normal;font-weight:600;line-height:normal;background:linear-gradient(90deg,#3b27ff,#2de3d6);background-clip:text;-webkit-background-clip:text;color:transparent;-webkit-text-fill-color:transparent;display:inline-block}.ai-loader-icon-medium img{width:40px;height:40px;flex-shrink:0}.heading{color:#000;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal;margin:10px 0}.pdf-heading{color:#000;font-family:Montserrat;font-size:18px;font-style:normal;font-weight:600;line-height:normal;margin:10px 0;text-align:center}.popup-header{display:flex;justify-content:space-between;align-items:center;padding:16px;border-bottom:1px solid #e0e0e0}.header-left{flex:1}.header-actions{display:flex;align-items:center;gap:12px}.regenerate-btn{display:flex;align-items:center;gap:8px;padding:8px 16px;border-radius:6px;font-size:14px;font-weight:500;min-width:auto}.regenerate-btn .mat-icon{margin:0;font-size:18px;width:18px;height:18px}.regenerate-btn .mat-spinner{margin:0}.regenerate-btn:disabled{opacity:.7;cursor:not-allowed}.close-btn{padding:8px;border-radius:4px;transition:background-color .2s ease}.close-btn:hover{background-color:#f5f5f5}.close-btn .mat-icon{font-size:20px;width:20px;height:20px}.progress-popup{display:flex;flex-direction:column;justify-content:center;align-items:center}.progress-popup .desc{color:#000000de;text-align:center;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal}.behavioural-pill{display:flex;padding:2px 6px;justify-content:center;align-items:center;gap:4px;border-radius:16px;border:1px solid #F8B861;background:linear-gradient(0deg,#f8b86152 0% 100%),#fff;margin:2px 4px 2px 0;font-size:12px}.functional-pill{display:flex;padding:2px 6px;justify-content:center;align-items:center;gap:4px;border-radius:16px;border:1px solid #E24577;background:linear-gradient(0deg,#e245773d 0% 100%),#fff;margin:2px 4px 2px 0;font-size:12px}.domain-pill{display:flex;padding:2px 6px;justify-content:center;align-items:center;gap:4px;border-radius:16px;border:1px solid #7B47A4;background:linear-gradient(0deg,#7b47a43d 0% 100%),#fff;margin:2px 4px 2px 0;font-size:12px}.popup-header{display:flex;flex-direction:row;justify-content:space-between}.popup-footer{display:flex;flex-direction:row;justify-content:end}.view-cbp-plan{margin:10px;padding:10px}.view-cbp-plan-popup{padding:24px;max-height:70vh;overflow-y:auto}.section{border-radius:8px;background:#1b4ca114;padding:16px}.popup-header{display:flex;justify-content:space-between;align-items:center;border-bottom:1px solid #ddd;font-weight:700;flex-shrink:0}.popup-footer{display:flex;justify-content:flex-end;gap:16px;padding:16px 24px;border-top:1px solid #ddd;background-color:#fff;flex-shrink:0;position:sticky;bottom:0}.section-container{overflow-y:auto;flex:1 1 auto}.competency-list{display:flex;flex-direction:row;gap:0px;flex-wrap:wrap;margin:0;padding:0;list-style:none}.competency-text{color:#000;font-family:Lato;font-size:12px;font-style:normal;font-weight:400;line-height:normal;padding:3px 6px}.competency-text-behavioral{color:#654321;font-family:Lato;font-size:14px;font-style:normal;line-height:normal;font-weight:550}.competency-text-functional{color:#b01669;font-family:Lato;font-size:14px;font-style:normal;line-height:normal;font-weight:550}.competency-text-domain{color:#301934;font-family:Lato;font-size:14px;font-style:normal;line-height:normal;font-weight:550}.competency-sub-heading{color:#1b4ca1;font-family:Montserrat;font-size:14px;font-style:normal;font-weight:600;line-height:normal}.cursor-pointer{cursor:pointer}.btn-active{border-radius:var(--Radius-Full-Round, 9999999px);opacity:1;background:var(--Primary-KB-Primary-Light, #1B4CA1);color:var(--white-kb-white-100, #FFF);text-align:center;font-family:Lato;font-size:14px;font-style:normal;font-weight:700;line-height:normal;display:flex;height:32px;padding:0 16px;justify-content:center;align-items:center;gap:8px;border:none}.custom-textarea{color:#000;font-family:Lato;font-size:14px;font-style:normal;font-weight:400;line-height:normal}.initial-loading-container{display:flex;justify-content:center;align-items:center;min-height:400px;width:100%}.initial-loading-container .loading-content{display:flex;flex-direction:column;align-items:center;text-align:center;padding:3rem 2rem}.initial-loading-container .loading-content .loading-text{color:#1b4ca1;font-family:Lato,sans-serif;min-width:320px}.initial-loading-container .loading-content .loading-text .main-message{font-size:16px;font-weight:600;margin-bottom:1rem;color:#1b4ca1}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator{margin-bottom:.5rem}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container{width:300px;height:8px;background-color:#e0e0e0;border-radius:4px;overflow:hidden;margin-bottom:.5rem}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container .progress-bar{height:100%;background:linear-gradient(90deg,#1b4ca1,#4caf50);border-radius:4px;transition:width .3s ease-in-out}.initial-loading-container .loading-content .loading-text .progress-details .progress-indicator .progress-text{font-size:12px;color:#666;font-weight:500}.initial-loading-container .loading-content .loading-text .progress-details .time-estimate{font-size:12px;color:#888;font-style:italic}.overlay-loader{position:fixed;top:0;left:0;width:100vw;height:100vh;background:#ffffffbf;z-index:9999;display:flex;justify-content:center;align-items:center}.overlay-loader .loading-content{display:flex;flex-direction:column;align-items:center;text-align:center;background:#fff;padding:2rem;border-radius:8px;box-shadow:0 4px 12px #00000026}.overlay-loader .loading-content .loading-text{color:#1b4ca1;font-family:Lato,sans-serif;min-width:320px}.overlay-loader .loading-content .loading-text .main-message{margin:0 0 16px;font-size:18px;font-weight:600;text-align:center}.overlay-loader .loading-content .loading-text .progress-details{margin-top:16px}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator{margin-bottom:12px}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container{width:100%;height:8px;background-color:#e0e0e0;border-radius:4px;overflow:hidden;margin-bottom:8px}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator .progress-bar-container .progress-bar{height:100%;background:linear-gradient(90deg,#1b4ca1,#2563eb);border-radius:4px;transition:width .5s ease-in-out}.overlay-loader .loading-content .loading-text .progress-details .progress-indicator .progress-text{font-size:14px;font-weight:500;color:#1b4ca1;display:block;text-align:center}.overlay-loader .loading-content .loading-text .progress-details .time-estimate{color:#666;font-size:12px;font-style:italic;display:block;text-align:center;margin-top:8px}.competencis-grid{display:flex;flex-direction:row;justify-content:space-between;gap:16px}.grid-list-item-behavioral div{border-left:2px solid darkorange}.grid-list-item-functional div{border-left:2px solid #ff1493}.grid-list-item-domain div{border-left:2px solid #6b21a8}.competencies-grid-3{width:33%}.bg-blue-50{background-color:#fde8cc;border-radius:4px}.bg-green-50{background-color:#f8d2de;border-radius:4px}.bg-purple-50{background-color:#dfd3e9;border-radius:4px}.grid-list-item div{padding:5px 10px;margin:10px 0}.course-pill-container{display:flex;gap:8px}.relevancy-pill-green{display:flex;padding:4px 8px;align-items:center;gap:4px;border-radius:16px;border:1px solid #e0e0e0;background:#f8f9fa}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.show-more-competency{display:inline-flex;align-items:center}.show-more-link{color:#1b4ca1;font-family:Lato;font-size:12px;font-style:normal;font-weight:500;line-height:normal;margin:2px 4px 2px 0;text-decoration:none}.show-more-link:hover{text-decoration:underline}.course-content{flex:1;display:flex;flex-direction:column}.course-footer{margin-top:auto;padding-top:12px;display:flex;justify-content:space-between}::ng-deep .mdc-tab__text-label{font-weight:700;font-family:Montserrat!important;font-size:16px;color:#000!important;text-transform:capitalize}.competency-tag{display:inline-block;padding:.25rem .75rem;border-radius:9999px;font-size:.75rem;font-weight:500;margin-right:.5rem;margin-bottom:.5rem}.menu-list-item.active{background-color:#1b4ca1;color:#fff}.menu-list-item:hover{background-color:#1b4ca1;color:#fff;border-color:#1b4ca1}.gray-bg{background-color:rgb(248,250,252,var(--tw-bg-opacity, 1));border-radius:8px;border:1px solid #ccc}.div-count{font-family:Lato;font-size:20px;font-weight:700}.green-bg{background-color:#0080001c;border:1px solid #006400;border-radius:8px}.div-green-count{font-family:Lato;font-size:20px;font-weight:700;color:#006400}.div-green-label{color:#006400;font-family:Montserrat;font-size:16px;font-style:normal;font-weight:600;line-height:normal}.gray-bg-item{background-color:rgb(248,250,252,var(--tw-bg-opacity, 1));border-radius:8px;border:1px solid #ccc;padding:4px 8px;margin:10px}.add-btn{color:#1b4ca1;font-size:14px;font-family:Lato}.list-flex{display:flex;flex-direction:row;justify-content:space-between}.all-category-list .mat-icon{vertical-align:middle}.course-list-container-flex{display:flex;align-items:flex-start;gap:2rem}.left-panel{flex:0 0 250px;font-weight:700;text-align:left}.right-panel{flex:1;display:flex;flex-direction:row;flex-wrap:wrap;gap:20px;align-content:flex-start;justify-content:flex-start}.category-list-item{font-weight:400;font-size:16px;font-family:Lato;padding:5px}.right-panel-flex{display:flex;flex:0 0 100%;width:100%;flex-direction:row;flex-wrap:wrap;gap:20px;justify-content:flex-start}.course-list-container-right-flex{display:flex}.no-gaps-message{display:flex;flex-direction:column;align-items:center;padding:24px;background:linear-gradient(135deg,#4caf501a,#81c7841a);border:2px solid #4CAF50;border-radius:16px;margin:16px 0}.no-gaps-message .success-icon{font-size:25px;color:#4caf50;margin-bottom:16px}.no-gaps-message h4{color:#2e7d32;font-family:Montserrat;font-size:20px;font-weight:600;margin:0 0 8px;text-align:center}.no-gaps-message p{color:#388e3c;font-family:Lato;font-size:14px;font-weight:400;margin:0;text-align:center;line-height:1.5}.section-header-improved,.section-header-improved-sec-2{display:flex;flex-direction:row;gap:0px;width:100%}.search-and-buttons-container{display:flex;justify-content:space-between;gap:5px;flex-direction:column;flex-wrap:wrap;width:37%;margin:0 5px}.search-container-compact{flex:0 0 auto;min-width:180px}.search-container-compact .rsearch{position:relative;display:flex;align-items:center}.search-container-compact .search-icon{position:absolute;left:12px;color:#666;font-size:20px;z-index:1}.search-container-compact .sinput-compact{border-radius:25px;border:2px solid #ccc;padding:20px 12px 20px 40px;height:32px;width:100%;font:400 14px Lato;box-sizing:border-box;transition:border-color .3s ease}.search-container-compact .sinput-compact:focus{outline:none;border-color:#1b4ca1;box-shadow:0 0 0 2px #1b4ca11a}.search-container-compact .sinput-compact::placeholder{color:#999}.btn-group-compact{display:flex;gap:8px;flex:0 0 auto}.category-list-item{padding:8px 12px!important;border-radius:6px;border:1px solid transparent;transition:all .3s ease;background:#f8f9fa;color:#333;font-family:Lato;font-size:14px!important;font-weight:400!important}.category-list-item:hover{background:#1b4ca10d;border-color:#1b4ca133}.category-list-item.selected-theme{background:#1b4ca11a;border-color:#1b4ca1;color:#1b4ca1;font-weight:600!important}.category-list-item.selected-theme:before{content:\"\\2713  \";color:#1b4ca1;font-weight:700}.theme-filter-controls{margin-bottom:8px}.clear-filter-btn{background:#f8f9fa;border:1px solid #ddd;border-radius:20px;padding:4px 12px;font-size:12px;color:#666;cursor:pointer;transition:all .3s ease;display:flex;align-items:center;gap:4px}.clear-filter-btn:hover{background:#e9ecef;border-color:#adb5bd}.clear-filter-btn mat-icon{font-size:16px;width:16px;height:16px}.no-course-found-container{display:flex;justify-content:center;align-items:center;min-height:300px;padding:20px}.no-course-card{background:linear-gradient(135deg,#f8f9fa,#e9ecef);border:2px dashed #ced4da;border-radius:16px;padding:40px;text-align:center;max-width:500px;box-shadow:0 4px 12px #0000000d}.no-course-card .no-course-icon{margin-bottom:20px}.no-course-card .no-course-icon mat-icon{font-size:48px;width:48px;height:48px;color:#6c757d}.no-course-card .no-course-content h4{color:#495057;font-family:Montserrat;font-size:24px;font-weight:600;margin-bottom:12px}.no-course-card .no-course-content p{color:#6c757d;font-family:Lato;font-size:16px;line-height:1.5;margin-bottom:12px}.no-course-card .no-course-content p strong{color:#1b4ca1;font-weight:600}.no-course-card .suggest-course-btn{background:linear-gradient(135deg,#1b4ca1,#164080);color:#fff;border:none;border-radius:25px;padding:12px 24px;font-family:Lato;font-size:14px;font-weight:600;cursor:pointer;display:flex;align-items:center;gap:8px;margin:20px auto 0;transition:all .3s ease;box-shadow:0 4px 12px #1b4ca14d}.no-course-card .suggest-course-btn:hover{background:linear-gradient(135deg,#164080,#0f2f5f);transform:translateY(-2px);box-shadow:0 6px 16px #1b4ca166}.no-course-card .suggest-course-btn:active{transform:translateY(0)}.no-course-card .suggest-course-btn mat-icon{font-size:18px;width:18px;height:18px}.left-panel{flex:0 0 280px!important;background:#f8f9fa;border-radius:12px;padding:16px;border:1px solid #e9ecef;max-height:600px;overflow-y:auto;font-weight:400!important}@media (max-width: 1200px){.search-and-buttons-container{flex-direction:column;align-items:stretch}.search-container-compact{min-width:auto;width:100%}.btn-group-compact{justify-content:center;flex-wrap:wrap}}@media (max-width: 1200px) and (min-width: 769px){.course-list-item{flex:1 1 calc(50% - 10px);min-width:300px;max-width:none}}@media (max-width: 768px){.course-list-container-flex{flex-direction:column}.left-panel{flex:none!important;max-height:300px}.course-list-item{flex:0 0 100%;max-width:100%}.no-course-card{padding:20px}.no-course-card .no-course-content h4{font-size:20px}.no-course-card .no-course-content p{font-size:14px}}::ng-deep .error-snackbar{background-color:#f44336!important;color:#fff!important;font-weight:500}::ng-deep .error-snackbar .mat-simple-snackbar-action{color:#fff!important}::ng-deep .session-expired-snackbar{background-color:#ff9800!important;color:#fff!important;font-weight:600}::ng-deep .session-expired-snackbar .mat-simple-snackbar-action{color:#fff!important;font-weight:700}.download-pdf{justify-content:end;display:flex;flex-direction:row}.gap-analysis-pdf-container{font-family:Lato;max-width:900px;margin:auto;color:#212121}.gap-analysis-pdf-header{text-align:center;margin-bottom:2rem}.gap-analysis-pdf-header .logo{height:60px;margin-bottom:.5rem}.gap-analysis-pdf-header h1{font-size:1.8rem;font-weight:600;margin:.5rem 0}.gap-analysis-pdf-header .subtitle{color:#555;font-size:.95rem}.gap-analysis-pdf-header .download-btn{background:#5e00ff;color:#fff;border:none;padding:10px 20px;border-radius:6px;margin-top:1rem;font-weight:500;cursor:pointer}.competency-snapshot{background:#fafafa;border-radius:12px;padding:2rem;margin-bottom:2rem}.competency-snapshot h2{font-size:1.4rem;font-weight:600;margin-bottom:1.5rem}.competency-snapshot .snapshot-content{display:flex;gap:2rem;align-items:center;justify-content:space-between}.competency-snapshot .snapshot-content .circle-wrapper{position:relative;width:120px;height:120px}.competency-snapshot .snapshot-content .circle-wrapper .progress-ring-bg{fill:none;stroke:#eee;stroke-width:10}.competency-snapshot .snapshot-content .circle-wrapper .progress-ring-circle{fill:none;stroke:#6c63ff;stroke-width:10;stroke-linecap:round;stroke-dasharray:326.72;stroke-dashoffset:117.6192;transform:rotate(-90deg);transform-origin:center;transition:stroke-dashoffset .35s}.competency-snapshot .snapshot-content .circle-wrapper .percentage-text{position:absolute;top:50%;left:50%;transform:translate(-50%,-50%);font-weight:600;font-size:1.4rem;text-align:center}.competency-snapshot .snapshot-content .circle-wrapper .percentage-text span{display:block;font-size:.75rem;font-weight:400;color:#555}.competency-snapshot .snapshot-content .details{flex-grow:1}.competency-snapshot .snapshot-content .details .total-competencies{font-size:1.2rem;margin-bottom:1rem}.competency-snapshot .snapshot-content .details .bar{margin:.5rem 0;padding:.6rem 1rem;border-radius:6px;font-weight:500;display:flex;justify-content:space-between;color:#fff}.competency-snapshot .snapshot-content .details .bar.behavioral{background:#7b1fa2}.competency-snapshot .snapshot-content .details .bar.functional{background:#0288d1}.competency-snapshot .snapshot-content .details .bar.domain{background:#f57c00}.gap-section{margin-top:2rem}.gap-section h2{font-size:1.3rem;margin-bottom:1rem}.gap-section .gap-box{background:#eef1ff;border-left:5px solid #6c63ff;padding:1rem;border-radius:6px;font-weight:500;color:#333}.gap-section .green-bg{background-color:#0080001c;border-left:5px solid #2d9b2d;padding:1rem;border-radius:6px;font-weight:500;color:#006400}.competency-container{width:100%;margin:0 auto;font-family:Segoe UI,sans-serif;color:#212121;display:flex;flex-direction:column}.total-box{background:#f8f9fc;border-radius:10px;padding:1.5rem;text-align:center;border:1px solid #e0e0e0;margin-bottom:1.5rem}.total-box .title{font-size:1rem;color:#666}.total-box .count{font-size:2rem;font-weight:700;color:#111;margin-top:.5rem}.progress-group{margin-bottom:1.5rem}.progress-group .progress-label{display:flex;justify-content:space-between;margin-bottom:6px}.progress-group .progress-label .label-text{font-weight:600}.progress-group .progress-label .covered-text{font-size:.9rem;color:#444}.progress-group .progress-label .behavioral{color:#f8b861}.progress-group .progress-label .functional{color:#e24577}.progress-group .progress-label .domain{color:#7b47a4}.progress-group .progress-bar{height:10px;background-color:#e0e0e0;border-radius:5px;overflow:hidden}.progress-group .progress-bar .progress-fill{height:100%;border-radius:5px;transition:width .5s ease-in-out}.progress-group .progress-bar .progress-fill.behavioral{background:#f8b861}.progress-group .progress-bar .progress-fill.functional{background:#e24577}.progress-group .progress-bar .progress-fill.domain{background:#7b47a4}.competency-card{border-radius:8px;padding:1rem 1.5rem;margin-bottom:1rem;border:1px solid transparent}.competency-card .title{font-weight:600;font-size:1.1rem;color:#222;margin-bottom:.4rem}.competency-card .subtitle{font-size:.95rem;color:#555}.competency-card .subtitle .tag{font-weight:500}.competency-card .subtitle .behavioral,.competency-card .subtitle .domain,.competency-card .subtitle .functional{color:#000}.competency-card.behavioral{background:linear-gradient(0deg,#f8b86152 0% 100%),#fff;border-color:#f8b861}.competency-card.functional{background:linear-gradient(0deg,#e245773d 0% 100%),#fff;border-color:#e24577}.competency-card.domain{background:linear-gradient(0deg,#7b47a43d 0% 100%),#fff;border-color:#7b47a4}.disclaimer-container{margin:8px 16px 0}.disclaimer-message{background-color:#fff3cd;border:1px solid #ffeaa7;border-radius:20px;padding:8px 16px;font-family:Lato;font-size:14px;color:#333;line-height:1.2}.disclaimer-message strong{color:#000;font-weight:600}.select-all-container{display:flex;flex-direction:row;justify-content:space-between}:host ::ng-deep .search-and-buttons-container .mat-form-field-infix{padding:10px!important}:host ::ng-deep .search-and-buttons-container .mat-form-field-wrapper{width:100%!important}:host ::ng-deep .select-search-panel{border:1px solid #ccc!important;border-radius:12px!important;box-shadow:0 8px 20px #0000001f}:host ::ng-deep .mat-select-arrow-wrapper{margin-top:5px!important}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline{color:#ccc}:host ::ng-deep .mat-form-field-appearance-outline.mat-focused .mat-form-field-outline-thick{color:#1b4ca1;border-color:#1b4ca1!important}:host ::ng-deep .select-search-panel .mat-option.mat-selected:not(.mat-option-disabled){background-color:#1b4ca1!important;color:#fff!important}:host ::ng-deep .mat-form-field-appearance-outline{border-radius:25px;border:1px solid #ccc}:host ::ng-deep .mat-form-field-focused .mat-form-field-appearance-outline{border-color:#1b4ca1!important}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline-start{border-radius:25px 0 0 25px;border:none!important}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline-end{border-right:none!important;border:none!important;border-radius:0 25px 25px 0}:host ::ng-deep .mat-form-field-appearance-outline .mat-form-field-outline-gap{border:none!important;border-radius:25px}:host::ng-deep .mat-form-field-appearance-outline .mat-form-field-infix{background-color:transparent!important}:host ::ng-deep .search-and-buttons-container .mat-option-text{color:#fff!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_DIALOG_DATA]
+                }] }, { type: i2.SharedService }, { type: i3.MatSnackBar }, { type: i1.MatDialog }, { type: i4.FormBuilder }]; }, propDecorators: { pdfContent: [{
+                type: ViewChild,
+                args: ['pdfContent', { static: false }]
+            }] } });
+// Confirmation Dialog Component
+export class RegenerateConfirmationDialog {
+    constructor(dialogRef) {
+        this.dialogRef = dialogRef;
+    }
+    onCancel() {
+        this.dialogRef.close(false);
+    }
+    onConfirm() {
+        this.dialogRef.close(true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RegenerateConfirmationDialog, deps: [{ token: i1.MatDialogRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: RegenerateConfirmationDialog, selector: "regenerate-confirmation-dialog", ngImport: i0, template: `
+    <div class="confirmation-dialog-container">
+      <div class="dialog-header">
+        <mat-icon class="warning-icon">refresh</mat-icon>
+        <h2 mat-dialog-title>Regenerate Course Recommendations</h2>
+      </div>
+      
+      <mat-dialog-content class="dialog-content">
+        <p class="main-message">
+          This will delete all current course recommendations and generate new ones based on the latest role mapping.
+        </p>
+        <p class="sub-message">
+          Are you sure you want to continue?
+        </p>
+      </mat-dialog-content>
+      
+      <mat-dialog-actions class="dialog-actions">
+        <button mat-button (click)="onCancel()" class="cancel-btn">
+          Cancel
+        </button>
+        <button mat-raised-button color="primary" (click)="onConfirm()" class="confirm-btn">
+          <mat-icon>refresh</mat-icon>
+          Yes, Regenerate
+        </button>
+      </mat-dialog-actions>
+    </div>
+  `, isInline: true, styles: [".confirmation-dialog-container{padding:0}.dialog-header{display:flex;align-items:center;gap:12px;padding:24px 24px 16px;border-bottom:1px solid #e0e0e0}.warning-icon{font-size:24px;width:24px;height:24px;color:#ff9800}h2{margin:0;font-size:18px;font-weight:600;color:#333}.dialog-content{padding:24px}.main-message{font-size:16px;color:#333;margin:0 0 12px;line-height:1.5}.sub-message{font-size:14px;color:#666;margin:0;font-weight:500}.dialog-actions{padding:16px 24px 24px;gap:12px;justify-content:flex-end}.cancel-btn{color:#666}.confirm-btn{display:flex;align-items:center;gap:8px;.mat-icon{font-size:18px;width:18px;height:18px;margin:0}}\n"], dependencies: [{ kind: "component", type: i8.MatLegacyButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "component", type: i9.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i1.MatDialogTitle, selector: "[mat-dialog-title], [matDialogTitle]", inputs: ["id"], exportAs: ["matDialogTitle"] }, { kind: "directive", type: i1.MatDialogContent, selector: "[mat-dialog-content], mat-dialog-content, [matDialogContent]" }, { kind: "directive", type: i1.MatDialogActions, selector: "[mat-dialog-actions], mat-dialog-actions, [matDialogActions]", inputs: ["align"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RegenerateConfirmationDialog, decorators: [{
+            type: Component,
+            args: [{ selector: 'regenerate-confirmation-dialog', template: `
+    <div class="confirmation-dialog-container">
+      <div class="dialog-header">
+        <mat-icon class="warning-icon">refresh</mat-icon>
+        <h2 mat-dialog-title>Regenerate Course Recommendations</h2>
+      </div>
+      
+      <mat-dialog-content class="dialog-content">
+        <p class="main-message">
+          This will delete all current course recommendations and generate new ones based on the latest role mapping.
+        </p>
+        <p class="sub-message">
+          Are you sure you want to continue?
+        </p>
+      </mat-dialog-content>
+      
+      <mat-dialog-actions class="dialog-actions">
+        <button mat-button (click)="onCancel()" class="cancel-btn">
+          Cancel
+        </button>
+        <button mat-raised-button color="primary" (click)="onConfirm()" class="confirm-btn">
+          <mat-icon>refresh</mat-icon>
+          Yes, Regenerate
+        </button>
+      </mat-dialog-actions>
+    </div>
+  `, styles: [".confirmation-dialog-container{padding:0}.dialog-header{display:flex;align-items:center;gap:12px;padding:24px 24px 16px;border-bottom:1px solid #e0e0e0}.warning-icon{font-size:24px;width:24px;height:24px;color:#ff9800}h2{margin:0;font-size:18px;font-weight:600;color:#333}.dialog-content{padding:24px}.main-message{font-size:16px;color:#333;margin:0 0 12px;line-height:1.5}.sub-message{font-size:14px;color:#666;margin:0;font-weight:500}.dialog-actions{padding:16px 24px 24px;gap:12px;justify-content:flex-end}.cancel-btn{color:#666}.confirm-btn{display:flex;align-items:center;gap:8px;.mat-icon{font-size:18px;width:18px;height:18px;margin:0}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialogRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-course-recommendation.component.js","sourceRoot":"","sources":["../../../../../../../library/sunbird-cb/cbp-ai/src/lib/components/generate-course-recommendation/generate-course-recommendation.component.ts","../../../../../../../library/sunbird-cb/cbp-ai/src/lib/components/generate-course-recommendation/generate-course-recommendation.component.html"],"names":[],"mappings":"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","sourcesContent":["import { MAT_DIALOG_DATA, MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { ChangeDetectorRef, Component, ElementRef, Inject, OnInit, ViewChild } from '@angular/core';\nimport { FormBuilder, FormGroup, FormArray, Validators, FormControl } from '@angular/forms';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { SuggestMoreCoursesComponent } from '../suggest-more-courses/suggest-more-courses.component';\nimport { MatTabChangeEvent } from '@angular/material/tabs';\nimport { AddCourseComponent } from '../add-course/add-course.component';\nimport html2pdf from 'html2pdf.js';\nimport { interval, of } from 'rxjs';\nimport { switchMap, takeWhile, tap, catchError, finalize } from 'rxjs/operators';\nimport { SharedService } from '../../modules/shared/services/shared.service';\n@Component({\n  selector: 'app-generate-course-recommendation',\n  templateUrl: './generate-course-recommendation.component.html',\n  styleUrls: ['./generate-course-recommendation.component.scss']\n})\nexport class GenerateCourseRecommendationComponent {\n  @ViewChild('pdfContent', { static: false }) pdfContent!: ElementRef;\n  planData: any\n  loading = false\n  dataLoaded = false // Track if initial data has been loaded\n  isRegeneratingWithProgress = false // Track regeneration with progress loading\n  recommended_course_id = ''\n  \n  // Progressive loading for course generation\n  currentProcessingStage: string = '';\n  progressPercentage: number = 0;\n  processingStages = [\n    'Analyzing roles and responsibilities...',\n    'Detailing competency requirements...',\n    'Preparing iGOT course recommendations...',\n    'Generating public course suggestions...',\n    'Computing comprehensive gap analysis...',\n    'Finalizing course recommendation plan...'\n  ];\n  stageStartTime: number = 0;\n  constructor(public dialogRef: MatDialogRef<GenerateCourseRecommendationComponent>,\n    @Inject(MAT_DIALOG_DATA) public data: any, public sharedService: SharedService,\n    private snackBar: MatSnackBar, public dialog: MatDialog,\n    private fb: FormBuilder) {\n    this.planData = data\n  }\n  searchText = ''\n  filterdCourses: any = []\n  originalData: any = []\n  selectFilterCourses: any = []\n  suggestedCourses: any = [] // Track iGOT suggested courses separately\n  userAddedCourses: any = [] // Track user-added courses separately\n  mode = 'add'\n  cbp_plan_id = ''\n  expandedCompetencies: any = {}; // Track expanded state for each course and competency type\n  outerTabActiveIndex = 0\n  innerTabActiveIndex = 0\n  outerTabActiveText = 'all'\n  innerTabActiveText = 'all'\n  selectedCategory = 'all';\n  competencyCoveredCount = 0\n  overallCoverage:any = 0\n  behavioralCompetencyCoveredCount = 0\n  behavioralTotalCompetencies = 0\n  behavioralCoverage: any = 0\n  functionalCompetencyCoveredCount = 0\n  functionalTotalCompetencies = 0\n  functionalCoverage: any = 0\n  domainCompetencyCoveredCount = 0\n  domainTotalCompetencies = 0\n  domainCoverage: any = 0\n  competencyNotMatchedByCategory = []\n  competencyMatchedByCategory = []\n  menuItems = [\n    { key: 'all', label: 'All Categories' },\n    { key: 'behavioral', label: 'Behavioural' },\n    { key: 'functional', label: 'Functional' },\n    { key: 'domain', label: 'Domain' }\n  ];\n  behaviouralNotMatched = []\n  functionalNotMatched = []\n  domainNotMatched = []\n  selectedThemeFilter = ''\n  originalFilteredCourses = []\n  isRegenerating = false\n  isPDFDownload = false\n  behaviouralMatched = []\n  functionalMatched = []\n  domainMatched = []\n  filterForm!: FormGroup;\n  competenciesType= ['All','Behavioural','Functional', 'Domain' ]\n  ratings = ['4.5 and above', '4.0 and above', '3.5 and above','2.5 and above','1 and above'];\n  languages = ['English', 'Hindi', 'Tamil','Kannada', 'Telugu', 'Malayalam', 'Assamese', 'Bengali', 'Gujarati', 'Marathi','Odia', 'Punjabi', 'Konkani', 'Bodo', 'Dogri', 'Kashmiri', 'Maithili','Manipuri', 'Nepali','Sanskrit','Santali','Sindhi','Urdu'];\n  durations = ['< 1 Hour', '1-5 Hours', '5+ Hours'];\n  providers = [];\n  filteredCompetency = [...this.competenciesType];\n  filteredRatings = [...this.ratings];\n  filteredLanguages = [...this.languages];\n  filteredDurations = [...this.durations];\n  filteredProviders = [...this.providers];\n  fullCourseList = []\n   // Selected filters\n  selectedCompetency = 'All';\n  selectedRating: string | null = null;\n  selectedLanguage: string | null = null;\n  selectedDuration: string | null = null;\n  selectedProvider: string | null = null;\n\n  selectCategory(category: string) {\n    this.selectedCategory = category;\n    this.gapAnalysisStats()\n  }\n  ngOnInit() {\n    this.filterForm = this.fb.group({\n      competency: [[]],\n      rating: [[]],\n      language: [[]],\n      duration: [[]],\n      provider: [[]]\n    });\n    this.loadComponentData();\n  }\n\n  applyFilter(value:any) {\n    console.log('this.searchText', value)\n    this.searchText = value\n    this.filterdCourses = this.filterData(this.searchText);\n  }\n\n  searchData() {\n    //  this.filterdCourses = this.filterData(this.searchText);\n  }\n\n  selectedFilterCourses(event, item) {\n    console.log('event', event)\n    console.log('item', item)\n    if (event.checked) {\n      if(this.selectFilterCourses.indexOf(item?.identifier) < 0) {\n        this.selectFilterCourses.push(item?.identifier)\n      }  \n    } else {\n      const index = this.selectFilterCourses.findIndex(\n        control => control === item.identifier\n      );\n\n      if (index !== -1) {\n        this.selectFilterCourses.splice(index, 1);\n      }\n    }\n    console.log('this.selectFilterCourses', this.selectFilterCourses)\n  }\n\n  closeDialog() {\n    this.dialogRef.close()\n  }\n\n  saveCourses() {\n    this.loading = true\n    console.log('this.planData', this.planData)\n    let reqBody = {\n      \"role_mapping_id\": this.planData.id,\n      \"recommended_course_id\": this.recommended_course_id,\n      \"course_identifiers\": this.selectFilterCourses\n    }\n    console.log('reqBody, ', reqBody)\n    if (this.mode === 'add') {\n      this.sharedService.saveCourse(reqBody).subscribe({\n        next: (res) => {\n          // Success handling\n          console.log('Success:', res);\n          this.loading = false\n          this.dialogRef.close('saved')\n          this.snackBar.open('Courses Saved Successfully', 'X', {\n            duration: 3000,\n            panelClass: ['snackbar-success']\n          });\n          //this.successRoleMapping.emit(this.roleMappingForm)\n        },\n        error: (error) => {\n          console.log('error', error)\n          this.dialogRef.close()\n          // Handle 409 Conflict here\n          // alert('Conflict detected: The resource already exists or action conflicts.');\n          //this.get\n          // Or you can set a UI error message variable\n          this.snackBar.open(error?.error?.detail, 'X', {\n            duration: 3000,\n            panelClass: ['snackbar-error']\n          });\n          this.loading = false\n          //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)\n        }\n      });\n    } else {\n      if (this.cbp_plan_id) {\n        this.sharedService.updateCourse(reqBody, this.cbp_plan_id).subscribe({\n          next: (res) => {\n            // Success handling\n            console.log('Success:', res);\n            this.loading = false\n            this.dialogRef.close('saved')\n            this.snackBar.open('Courses Updated Successfully', 'X', {\n              duration: 3000,\n              panelClass: ['snackbar-success']\n            });\n            //this.successRoleMapping.emit(this.roleMappingForm)\n          },\n          error: (error) => {\n            console.log('error', error)\n            this.dialogRef.close()\n            // Handle 409 Conflict here\n            // alert('Conflict detected: The resource already exists or action conflicts.');\n            //this.get\n            // Or you can set a UI error message variable\n            this.snackBar.open(error?.error?.detail, 'X', {\n              duration: 3000,\n              panelClass: ['snackbar-error']\n            });\n            this.loading = false\n            //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)\n          }\n        });\n      } else {\n        // Handle case when cbp_plan_id is not available\n        this.loading = false\n        console.error('cbp_plan_id is not available for update operation');\n        this.snackBar.open('Unable to update courses: missing plan ID', 'X', {\n          duration: 3000,\n          panelClass: ['snackbar-error']\n        });\n      }\n\n    }\n\n  }\n\n  getCourses() {\n    let role_mapping_id = this.planData.id\n    this.loading = true\n    this.sharedService.getCourse(role_mapping_id).subscribe({\n      next: (res) => {\n        // Success handling\n        this.loading = false\n        console.log('res', res)\n        this.cbp_plan_id = res?.id\n        if (res && res?.selected_courses && res?.selected_courses?.length) {\n          this.mode = 'edit'\n          for (let i = 0; i < res?.selected_courses.length; i++) {\n            this.selectFilterCourses.push(res.selected_courses[i]?.identifier)\n          }\n        }\n        //this.successRoleMapping.emit(this.roleMappingForm)\n      },\n      error: (error) => {\n        console.log('error', error)\n        this.loading = false\n        // Handle 409 Conflict here\n        // alert('Conflict detected: The resource already exists or action conflicts.');\n        //this.get\n        // Or you can set a UI error message variable\n\n        this.loading = false\n        //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)\n      }\n\n\n    })\n  }\n  getSuggestedCourse() {\n    let role_mapping_id = this.planData.id\n    this.loading = true\n    this.sharedService.getSuggestedCourses(role_mapping_id).subscribe({\n      next: (res) => {\n        // Success handling\n        this.loading = false\n        console.log('getSuggestedCourses res', res)\n        console.log('this.filterdCourses', this.filterdCourses)\n        // Store suggested courses separately\n        this.suggestedCourses = [...res];\n        \n        // Rebuild filterdCourses to include all course types\n        this.rebuildFilteredCourses();\n        \n        // Update gap analysis stats after suggested courses are added\n        this.updateGapAnalysisAfterCoursesUpdate()\n        //this.successRoleMapping.emit(this.roleMappingForm)\n      },\n      error: (error) => {\n        console.log('error', error)\n        this.loading = false\n        if (error.status === 401) {\n          console.log('Unauthorized access - user will be redirected to login');\n        } else {\n          // Handle other errors gracefully\n          console.error('Failed to load suggested courses');\n        }\n        // Or you can set a UI error message variable\n\n        this.loading = false\n        //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)\n      }\n\n\n    })\n  }\n\n  getUserCourse() {\n    let role_mapping_id = this.planData.id\n    this.loading = true\n    this.sharedService.getUserCourse(role_mapping_id).subscribe({\n      next: (res) => {\n        // Success handling\n        this.loading = false\n        console.log('getUserCourse API response:', res)\n        console.log('Current filterdCourses before adding user courses:', this.filterdCourses)\n        \n        // Store user-added courses separately (reset to avoid duplicates)\n        this.userAddedCourses = [...res];\n        \n        // Process user-added courses to ensure proper structure\n        for (let i = 0; i < res.length; i++) {\n          const userCourse = res[i];\n          console.log(`User course ${i} competencies:`, userCourse.competencies);\n          \n          // Ensure user-added courses have the expected structure for display\n          if (userCourse && !userCourse.course_type) {\n            userCourse.course_type = 'User Added';\n          }\n          \n          // Add identifier if missing (needed for course selection logic)\n          if (userCourse && !userCourse.identifier) {\n            userCourse.identifier = userCourse.id || `user_course_${i}_${Date.now()}`;\n          }\n        }\n        \n        // Rebuild filterdCourses to include all course types\n        this.rebuildFilteredCourses();\n        \n        console.log('filterdCourses after adding user courses:', this.filterdCourses);\n        //this.successRoleMapping.emit(this.roleMappingForm)\n      },\n      error: (error) => {\n        console.log('error', error)\n        this.loading = false\n        // Handle 409 Conflict here\n        // alert('Conflict detected: The resource already exists or action conflicts.');\n        //this.get\n        // Or you can set a UI error message variable\n\n        this.loading = false\n        //this.alreadyAvailableRoleMapping.emit(this.roleMappingForm)\n      }\n\n\n    })\n  }\n\n  checkIfCourseExists(item) {\n    let flag = false\n    if (this.selectFilterCourses.indexOf(item?.identifier) > -1) {\n      flag = true\n    }\n    return flag\n  }\n\n  selectAllCourses(event) {\n    if (event.checked) {\n      for (let i = 0; i < this.filterdCourses.length; i++) {\n        this.selectFilterCourses.push(this.filterdCourses[i].identifier)\n      }\n    } else {\n      this.selectFilterCourses = []\n      \n    }\n    if(this.cbp_plan_id) {\n      this.mode = 'update'\n    } else {\n      this.mode = 'add'\n    }\n\n\n  }\n  getSectors(sector) {\n    if (sector && sector.length) {\n      return Array.isArray(sector) ? sector.join('/ ') : ''\n    }\n\n  }\n\n  filterData(searchText: string): any[] {\n    const filter = searchText.trim().toLowerCase();\n\n    return this.originalData.filter(item => {\n      const stringified = this.flattenObjectToString(item).toLowerCase();\n      return stringified.includes(filter);\n    });\n  }\n\n  flattenObjectToString(obj: any): string {\n    let result = '';\n\n    for (const key in obj) {\n      const value = obj[key];\n\n      if (typeof value === 'string') {\n        result += ' ' + value;\n      } else if (Array.isArray(value)) {\n        value.forEach(val => {\n          if (typeof val === 'string') {\n            result += ' ' + val;\n          } else if (typeof val === 'object') {\n            result += ' ' + this.flattenObjectToString(val);\n          }\n        });\n      } else if (typeof value === 'object' && value !== null) {\n        result += ' ' + this.flattenObjectToString(value);\n      }\n    }\n\n    return result;\n  }\n\n  suggestMoreCourses() {\n    // this.dialogRef.close()\n    const dialogRefNew = this.dialog.open(SuggestMoreCoursesComponent, {\n      width: '1000px',\n      data: { recommended_course_id: this.recommended_course_id, role_mapping_id: this.planData.id },\n      panelClass: 'view-cbp-plan-popup',\n      minHeight: '400px',          // Set minimum height\n      maxHeight: '90vh',           // Prevent it from going beyond viewport\n      disableClose: true // Optional: prevent closing with outside click\n    });\n\n    dialogRefNew.afterClosed().subscribe(result => {\n      if (result === 'saved') {\n        console.log('Changes saved!');\n        // Refresh data or show a toast here\n        this.getSuggestedCourse()\n      }  else {\n        this.getSuggestedCourse()\n      }\n    });\n  }\n\n  generateCourseRecommendation(element: any) {\n    console.log('Generate Course Recommendation clicked', element);\n    // this.activeRowElement = element\n    console.log('Edit Role Mapping clicked', element);\n    // Navigate or open modal\n    console.log('View CBP Plan clicked', element);\n    const dialogRef = this.dialog.open(GenerateCourseRecommendationComponent, {\n      width: '1000px',\n      data: element,\n       panelClass: 'view-cbp-plan-popup',\n      minHeight: '400px',          // Set minimum height\n      maxHeight: '90vh',           // Prevent it from going beyond viewport\n      disableClose: true // Optional: prevent closing with outside click\n    });\n  \n    dialogRef.afterClosed().subscribe(result => {\n      if (result === 'saved') {\n        console.log('Changes saved!');\n        // Refresh data or show a toast here\n        console.log(this.sharedService.cbpPlanFinalObj)\n        if(this.sharedService.cbpPlanFinalObj && this.sharedService.cbpPlanFinalObj.ministry && this.sharedService.cbpPlanFinalObj.ministry.id) {\n          this.sharedService.getRoleMappingByStateCenter(this.sharedService.cbpPlanFinalObj.ministry.id).subscribe((res)=>{\n            console.log('res', res)\n            // this.dataSource.data = res\n            // this.dataSource.paginator = this.paginator;\n            this.originalData = res;\n          //  console.log('this.dataSource',this.dataSource)\n            })\n        } else {\n          \n        }\n        \n      }\n    });\n  }\n\n  getCompetenciesByType(type: string, index): any[] {\n    const course = this.filterdCourses[index];\n    if (!course) {\n      console.log(`No course found at index ${index}`);\n      return [];\n    }\n    \n    // Handle different competency property names\n    // AI Recommended & Public courses use 'competencies'\n    // Manually Suggested - iGOT courses use 'competencies_v6'\n    // User Added courses use 'competencies'\n    let competencies = [];\n    if (course.competencies && Array.isArray(course.competencies)) {\n      competencies = course.competencies;\n    //  console.log(`Course ${index} (${course.course_type || course.name || 'Unknown'}) using 'competencies' property:`, competencies);\n    } else if (course.competencies_v6 && Array.isArray(course.competencies_v6)) {\n      competencies = course.competencies_v6;\n     // console.log(`Course ${index} (${course.course_type || course.name || 'Unknown'}) using 'competencies_v6' property:`, competencies);\n    } else {\n      // console.log(`Course ${index} (${course.course_type || course.name || 'Unknown'}) has no valid competencies property:`, {\n      //   hasCompetencies: !!course.competencies,\n      //   competenciesType: typeof course.competencies,\n      //   hasCompetenciesV6: !!course.competencies_v6,\n      //   competenciesV6Type: typeof course.competencies_v6,\n      //   courseKeys: Object.keys(course)\n      // });\n    }\n    \n    if (competencies.length === 0) {\n    //  console.log(`No competencies found for course ${index} and type ${type}`);\n      return [];\n    }\n    \n    // Normalize the type for comparison (case-insensitive + handle spelling variations)\n    const normalizedType = type.toLowerCase().trim();\n    \n    const matchedCompetencies = competencies.filter(c => {\n      if (!c || !c.competencyAreaName) {\n        console.log(`Invalid competency structure in course ${index}:`, c);\n        return false;\n      }\n      \n      const competencyArea = c.competencyAreaName.toLowerCase().trim();\n      \n      // Handle both \"behavioral\" and \"behavioural\" spellings\n      if (normalizedType === 'behavioural' || normalizedType === 'behavioral') {\n        return competencyArea === 'behavioral' || competencyArea === 'behavioural';\n      }\n      \n      // For other types, do case-insensitive comparison\n      return competencyArea === normalizedType;\n    });\n    \n   // console.log(`Found ${matchedCompetencies.length} competencies of type ${type} for course ${index}:`, matchedCompetencies);\n    return matchedCompetencies;\n  }\n\n  getCompetenciesByBehviouralType(index): string {\n    const course = this.filterdCourses[index];\n    if (!course) {\n      return '';\n    }\n    \n    // Handle different competency property names\n    let competencies = [];\n    if (course.competencies && Array.isArray(course.competencies)) {\n      competencies = course.competencies;\n    } else if (course.competencies_v6 && Array.isArray(course.competencies_v6)) {\n      competencies = course.competencies_v6;\n    }\n    \n    if (competencies.length === 0) {\n      return '';\n    }\n    \n    return competencies\n      .filter(c => c && (c.competencyAreaName === 'Behavioral' || c.competencyAreaName === 'Behavioural'))\n      .map(c => `${c.competencyThemeName || ''} - ${c.competencySubThemeName || ''}`)\n      .join(', ');\n  }\n\n  getDisplayedCompetencies(type: string, index: number): any[] {\n    const competencies = this.getCompetenciesByType(type, index);\n    const key = `${index}-${type}`;\n\n    if (this.expandedCompetencies[key]) {\n      return competencies;\n    }\n\n    return competencies.slice(0, 2);\n  }\n\n  toggleCompetencies(type: string, index: number): void {\n    const key = `${index}-${type}`;\n    this.expandedCompetencies[key] = !this.expandedCompetencies[key];\n  }\n\n  isExpanded(type: string, index: number): boolean {\n    const key = `${index}-${type}`;\n    return this.expandedCompetencies[key] || false;\n  }\n\n  hasMoreThanTwo(type: string, index: number): boolean {\n    return this.getCompetenciesByType(type, index).length > 2;\n  }\n\n  getRemainingCount(type: string, index: number): number {\n    const totalCount = this.getCompetenciesByType(type, index).length;\n    return totalCount - 2;\n  }\n\n  onOuterTabChange(event: MatTabChangeEvent): void {\n    this.outerTabActiveIndex = event.index\n    this.outerTabActiveText = event.tab.textLabel\n    console.log('Outer Tab Index:', event.index);\n    console.log('Outer Tab Label:', event.tab.textLabel);\n    if(event.index === 1) {\n      this.gapAnalysisStats()\n    }\n    if(event.index === 0) {\n      // this.getCourses()\n      // this.getSuggestedCourse()\n      this.getUserCourse()\n    }\n  }\n\n  onInnerTabChange(event: MatTabChangeEvent): void {\n    this.innerTabActiveIndex = event.index\n    this.innerTabActiveText = event.tab.textLabel\n    this.selectedThemeFilter = ''; // Reset theme filter when switching tabs\n    console.log('Inner Tab Index:', event.index);\n    console.log('Inner Tab Label:', event.tab.textLabel);\n    let tabIndex = event.index\n    this.competencyMatchedByCategory = []\n    \n    // Get all available courses (original + suggested + user added)\n    const allAvailableCourses = this.getAllAvailableCourses();\n\n\n    \n    switch (tabIndex) {\n      case 0: // All\n        this.filterdCourses = allAvailableCourses;\n        break;\n      case 1: // Behavioral\n        this.filterdCourses = this.behavioralFilter(allAvailableCourses);\n        this.competencyMatchedByCategory = this.behavioralCompetencyFilter(this.planData.competencies);\n        break;\n      case 2: // Functional\n        this.filterdCourses = this.functionalFilter(allAvailableCourses);\n        this.competencyMatchedByCategory = this.functionalCompetencyFilter(this.planData.competencies);\n        break;\n      case 3: // Domain\n        this.filterdCourses = this.domainFilter(allAvailableCourses);\n        this.competencyMatchedByCategory = this.domainCompetencyFilter(this.planData.competencies);\n        break;\n    }\n    console.log('this.filterdCourses',this.filterdCourses)\n    console.log('this.competencyMatchedByCategory',this.competencyMatchedByCategory)\n  }\n  \n  getAllAvailableCourses() {\n    // Start with original data (AI recommended courses)\n    const allCourses = [...this.originalData];\n    const seenIdentifiers = new Set();\n    \n    // Track original course identifiers\n    this.originalData.forEach(course => {\n      if (course.identifier) seenIdentifiers.add(course.identifier);\n      if (course.id) seenIdentifiers.add(course.id);\n    });\n    \n    // Add suggested courses (iGOT platform courses)\n    this.suggestedCourses.forEach(course => {\n      const courseId = course.identifier || course.id;\n      if (courseId && !seenIdentifiers.has(courseId)) {\n        allCourses.push(course);\n        seenIdentifiers.add(courseId);\n      }\n    });\n    \n    // Add user-added courses\n    this.userAddedCourses.forEach(course => {\n      const courseId = course.identifier || course.id;\n      if (courseId && !seenIdentifiers.has(courseId)) {\n        // Ensure user-added courses have proper structure\n        if (!course.course_type) {\n          course.course_type = 'User Added';\n        }\n        if (!course.identifier && course.id) {\n          course.identifier = course.id;\n        }\n        allCourses.push(course);\n        seenIdentifiers.add(courseId);\n      }\n    });\n    \n    console.log('getAllAvailableCourses breakdown:', {\n      originalData: this.originalData.length,\n      suggestedCourses: this.suggestedCourses.length,\n      userAddedCourses: this.userAddedCourses.length,\n      totalAvailable: allCourses.length\n    });\n\n    console.log('allCourses--', allCourses)\n    allCourses.forEach((item)=>{\n      if(item && item.organisation && item.organisation.length) {\n        if(this.filteredProviders.indexOf(item.organisation[0]) < 0) {\n          this.filteredProviders.push(item.organisation[0])\n        }\n        \n      }\n    })\n    this.fullCourseList = allCourses\n    let identifiersArr = []\n    this.fullCourseList.map((item)=>{\n      identifiersArr.push(item?.identifier)\n    })\n    this.sharedService.getAdditionalParameterforSuggestedCourses(identifiersArr).subscribe((response)=>{\n      if(response && response.result && response.result.content && response.result.content.length) {\n        for(let i=0; i < response.result.content.length;i++) {\n          for(let j=0; j<this.fullCourseList.length;j++) {\n            if(this.fullCourseList[j]['identifier'] === response.result.content[i]['identifier'] ) {\n              this.fullCourseList[j]['language'] = response.result.content[i]['language']\n              this.fullCourseList[j]['avgRating'] = response.result.content[i]['avgRating']\n              this.fullCourseList[j]['course'] = response.result.content[i]['name']\n              break;\n            }\n          }\n          \n        }\n      }\n      \n    })\n    return allCourses;\n  }\n\n  \n  /**\n   * Rebuild filterdCourses array with all available course types\n   * This ensures consistency across the application\n   */\n  rebuildFilteredCourses() {\n    this.filterdCourses = this.getAllAvailableCourses();\n    \n    console.log('Rebuilt filterdCourses with all course types:', {\n      total: this.filterdCourses.length,\n      breakdown: {\n        original: this.originalData.length,\n        suggested: this.suggestedCourses.length,\n        userAdded: this.userAddedCourses.length\n      }\n    });\n  }\n\n  behavioralFilter(data: any[]): any[] {\n    return data.filter(item => {\n      if (!item) return false;\n      \n      // Handle different competency property names\n      let competencies = [];\n      if (item.competencies && Array.isArray(item.competencies)) {\n        competencies = item.competencies;\n      } else if (item.competencies_v6 && Array.isArray(item.competencies_v6)) {\n        competencies = item.competencies_v6;\n      }\n      \n      return competencies.some(c => c && ((c?.competencyAreaName?.toLowerCase() === 'behavioral') || c?.competencyAreaName?.toLowerCase() === 'behavioural'));\n    });\n  }\n\n  behavioralCompetencyFilter(data: any[]): string[] {\n    console.log('data--', data)\n    const behavioralThemes = data\n      .filter(item =>\n        item?.type &&\n        ['behavioral', 'behavioural'].includes(item.type.toLowerCase())\n      )\n      .map(item => `${item.theme}-${item.sub_theme}`)\n      .filter((theme): theme is string => Boolean(theme)); // Ensures type safety\n  \n    const uniqueBehavioralThemes = Array.from(new Set(behavioralThemes));\n    \n    console.log(uniqueBehavioralThemes);\n    return uniqueBehavioralThemes;\n  }\n\n  functionalCompetencyFilter(data:any[]):any {\n    const functionalThemes = data\n      .filter(item =>\n        item?.type &&\n        ['functional'].includes(item.type.toLowerCase())\n      )\n      .map(item => `${item.theme}-${item.sub_theme}`)\n      .filter((theme): theme is string => Boolean(theme)); // Ensures type safety\n  \n    const uniqueFunctionalThemes = Array.from(new Set(functionalThemes));\n    \n    console.log(uniqueFunctionalThemes);\n    return uniqueFunctionalThemes;\n    \n    // console.log(uniqueCompetencyAreaNames);\n  }\n\n  domainCompetencyFilter(data:any[]):any {\n    const domainThemes = data\n    .filter(item =>\n      item?.type &&\n      ['domain'].includes(item.type.toLowerCase())\n    )\n    .map(item => `${item.theme}-${item.sub_theme}`)\n    .filter((theme): theme is string => Boolean(theme)); // Ensures type safety\n\n  const uniqueDomainThemes = Array.from(new Set(domainThemes));\n  \n  console.log(uniqueDomainThemes);\n  return uniqueDomainThemes;\n    \n    // console.log(uniqueCompetencyAreaNames);\n  }\n\n\n  functionalFilter(data: any[]): any[] {\n    return data.filter(item => {\n      if (!item) return false;\n      \n      // Handle different competency property names\n      let competencies = [];\n      if (item.competencies && Array.isArray(item.competencies)) {\n        competencies = item.competencies;\n      } else if (item.competencies_v6 && Array.isArray(item.competencies_v6)) {\n        competencies = item.competencies_v6;\n      }\n      \n      return competencies.some(c => c && c?.competencyAreaName?.toLowerCase() === 'functional');\n    });\n  }\n\n  domainFilter(data: any[]): any[] {\n    return data.filter(item => {\n      if (!item) return false;\n      \n      // Handle different competency property names\n      let competencies = [];\n      if (item.competencies && Array.isArray(item.competencies)) {\n        competencies = item.competencies;\n      } else if (item.competencies_v6 && Array.isArray(item.competencies_v6)) {\n        competencies = item.competencies_v6;\n      }\n      \n      return competencies.some(c => c && c?.competencyAreaName?.toLowerCase() === 'domain');\n    });\n  }\n\n  gapAnalysisStats () {\n    console.log('this.planData',this.planData)\n    \n    // Always use ALL competencies for calculating overall stats\n    const allCompetencies = this.planData.competencies;\n    \n    // Filter for category-specific calculations\n    let categorySpecificCompetencies:any = this.planData.competencies;\n    if(this.selectedCategory === 'all') {\n      categorySpecificCompetencies = this.planData.competencies\n    } else if(this.selectedCategory === 'behavioral') {\n      categorySpecificCompetencies = this.planData.competencies.filter(item => item.type?.toLowerCase() === this.selectedCategory);\n    } else if(this.selectedCategory === 'functional') {\n      categorySpecificCompetencies = this.planData.competencies.filter(item => item.type?.toLowerCase() === this.selectedCategory);\n    } \n    else if(this.selectedCategory === 'domain') {\n      categorySpecificCompetencies = this.planData.competencies.filter(item => item.type?.toLowerCase() === this.selectedCategory);\n    } \n\n    // Count ALL competencies by category (not just filtered ones)\n    const masterListByCategory = {total: allCompetencies.length, behavioural: 0, functional:0, domain:0}\n    \n    // IMPORTANT: Use all available courses for consistent coverage calculation\n    // This should match what's available in the Filter By Competency section\n    const allCourseCompetencies = []\n    const allAvailableCoursesForStats = this.getAllAvailableCourses();\n    \n    allAvailableCoursesForStats.forEach(course => {\n      // Handle different competency property names\n      let competencies = [];\n      if (course && course.competencies && Array.isArray(course.competencies)) {\n        competencies = course.competencies;\n      } else if (course && course.competencies_v6 && Array.isArray(course.competencies_v6)) {\n        competencies = course.competencies_v6;\n      }\n      \n      competencies.forEach((list:any) => {\n         allCourseCompetencies.push(list)\n      });\n    });\n    \n    console.log('allCompetencies', allCompetencies)\n    console.log('categorySpecificCompetencies', categorySpecificCompetencies)\n    console.log('allCourseCompetencies', allCourseCompetencies)\n    \n    // Count all competencies by type for proper totals\n    for(let i=0; i<allCompetencies.length;i++) {\n      const competencyType = allCompetencies[i]['type']?.toLowerCase();\n      console.log(`Competency ${i}: type=\"${competencyType}\", data:`, allCompetencies[i]);\n      if(competencyType === 'behavioural' || competencyType === 'behavioral') {\n        masterListByCategory['behavioural'] = masterListByCategory['behavioural'] + 1\n      }\n      if(competencyType === 'functional') {\n        masterListByCategory['functional'] = masterListByCategory['functional'] + 1\n      }\n      if(competencyType === 'domain') {\n        masterListByCategory['domain'] = masterListByCategory['domain'] + 1\n      }\n    }\n    console.log('masterListByCategory after counting:', masterListByCategory)\n    \n    // Get matching results for ALL competencies (for overall coverage)\n    const overallResult = this.getMatchedCompetencyStats(allCompetencies, allCourseCompetencies);\n    \n    // Get matching results for category-specific competencies (for filtered view)\n    const categoryResult = this.getMatchedCompetencyStats(categorySpecificCompetencies, allCourseCompetencies);\n    \n    // Set competencyCoveredCount based on selected category (for the filtered numbers)\n    if(this.selectedCategory === 'all') {\n      this.competencyCoveredCount = overallResult['total'];\n    } else if(this.selectedCategory === 'behavioral') {\n      this.competencyCoveredCount = categoryResult['behavioral'] || 0;\n    } else if(this.selectedCategory === 'functional') {\n      this.competencyCoveredCount = categoryResult['functional'] || 0;\n    } else if(this.selectedCategory === 'domain') {\n      this.competencyCoveredCount = categoryResult['domain'] || 0;\n    }\n    \n    // IMPORTANT: Overall Coverage should ALWAYS be based on ALL competencies, not filtered\n    let totalCompetencies = this.planData.competencies.length; // Always use total count\n    let overallCoveredCount = overallResult['total']; // Always use overall results\n    let mathRound = Math.round((overallCoveredCount/totalCompetencies)*100)\n    this.overallCoverage = `${mathRound}%`\n    \n    console.log('Overall Coverage Calculation:', {\n      totalCompetencies: totalCompetencies,\n      overallCoveredCount: overallCoveredCount,\n      overallCoverage: this.overallCoverage,\n      selectedCategory: this.selectedCategory,\n      competencyCoveredCount: this.competencyCoveredCount\n    });\n    \n    // Always calculate all category-specific metrics regardless of selected category\n    // This ensures the data is available when switching between categories\n    // Use overallResult for consistent calculations across all categories\n    this.behavioralCompetencyCoveredCount = overallResult['behavioral'] || 0;\n    this.behavioralTotalCompetencies = masterListByCategory['behavioural'];\n    let behavioralMathRound = this.behavioralTotalCompetencies > 0 ? Math.round((this.behavioralCompetencyCoveredCount/this.behavioralTotalCompetencies)*100) : 0;\n    this.behavioralCoverage = `${behavioralMathRound}%`;\n    \n    this.functionalCompetencyCoveredCount = overallResult['functional'] || 0;\n    this.functionalTotalCompetencies = masterListByCategory['functional'];\n    let functionalMathRound = this.functionalTotalCompetencies > 0 ? Math.round((this.functionalCompetencyCoveredCount/this.functionalTotalCompetencies)*100) : 0;\n    this.functionalCoverage = `${functionalMathRound}%`;\n    \n    this.domainCompetencyCoveredCount = overallResult['domain'] || 0;\n    this.domainTotalCompetencies = masterListByCategory['domain'];\n    let domainMathRound = this.domainTotalCompetencies > 0 ? Math.round((this.domainCompetencyCoveredCount/this.domainTotalCompetencies)*100) : 0;\n    this.domainCoverage = `${domainMathRound}%`;\n    \n    console.log('All category metrics calculated:', {\n      behavioral: { covered: this.behavioralCompetencyCoveredCount, total: this.behavioralTotalCompetencies, coverage: this.behavioralCoverage },\n      functional: { covered: this.functionalCompetencyCoveredCount, total: this.functionalTotalCompetencies, coverage: this.functionalCoverage },\n      domain: { covered: this.domainCompetencyCoveredCount, total: this.domainTotalCompetencies, coverage: this.domainCoverage },\n      overall: { covered: overallCoveredCount, total: totalCompetencies, coverage: this.overallCoverage },\n      selectedCategory: this.selectedCategory,\n      competencyCoveredCountForCategory: this.competencyCoveredCount\n    });\n    console.log('Overall Result:', overallResult);\n    console.log('Category Result:', categoryResult);\n    console.log('this.competencyNotMatchedByCategory',this.competencyNotMatchedByCategory)\n    this.behaviouralNotMatched = this.getCompetencyByCategoryNotMatching('behavioral')\n    this.functionalNotMatched = this.getCompetencyByCategoryNotMatching('functional')\n    this.domainNotMatched = this.getCompetencyByCategoryNotMatching('domain')\n\n    this.getBehaviouralMatched()\n    this.getFunctionalMatched()\n    this.getDomainMatched()\n  }\n\n  getMatchedCompetencyStats(primaryArray: any[], secondaryArray: any[]) {\n    // Convert both arrays to ensure consistent casing\n    const counts: any = {\n      behavioral: 0,\n      functional: 0,\n      domain: 0,\n      total: 0\n    };\n    \n    // Clear the competencyNotMatchedByCategory array for fresh calculation\n    this.competencyNotMatchedByCategory = [];\n    \n    // Set to keep track of unique matches\n    const seen = new Set<string>();\n    const matchedCompetencies = new Set<string>();\n    \n    for (const primary of primaryArray) {\n      const typeKey = primary.type?.toLowerCase().trim();\n      const themeKey = primary.theme?.toLowerCase().trim();\n      const subThemeKey = primary.sub_theme?.toLowerCase().trim();\n    \n      let isMatched = false;\n      \n      for (const secondary of secondaryArray) {\n        // Normalize secondary keys\n        let secType = secondary?.competencyAreaName?.toLowerCase().trim();\n        let secTheme = secondary?.competencyThemeName?.toLowerCase().trim();\n        let secSubTheme = secondary?.competencySubThemeName?.toLowerCase().trim();\n    \n        // Fix for data inconsistency\n        if (secType === 'behavioural') secType = 'behavioral';\n    \n        // Create unique match key for primary competency\n        const matchKey = `${typeKey}|${themeKey}|${subThemeKey}`;\n    \n        // Enhanced cross-matching logic as requested:\n        // 1. Role mapping Theme vs Course Theme\n        // 2. Role mapping Sub Theme vs Course Sub Theme  \n        // 3. Role mapping Theme vs Course Sub Theme\n        // 4. Role mapping Sub Theme vs Course Theme\n        const themeToThemeMatch = themeKey === secTheme;\n        const subThemeToSubThemeMatch = subThemeKey === secSubTheme;\n        const themeToSubThemeMatch = themeKey === secSubTheme;\n        const subThemeToThemeMatch = subThemeKey === secTheme;\n        \n        let matchType = '';\n        let isMatch = false;\n        \n        if (typeKey === secType && !seen.has(matchKey)) {\n          if (themeToThemeMatch) {\n            matchType = 'Theme-to-Theme';\n            isMatch = true;\n          } else if (subThemeToSubThemeMatch) {\n            matchType = 'SubTheme-to-SubTheme';\n            isMatch = true;\n          } else if (themeToSubThemeMatch) {\n            matchType = 'Theme-to-SubTheme';\n            isMatch = true;\n          } else if (subThemeToThemeMatch) {\n            matchType = 'SubTheme-to-Theme';\n            isMatch = true;\n          }\n        }\n\n        if (isMatch) {\n          console.log(`✅ MATCH FOUND [${matchType}]:`, {\n            roleMapping: { type: typeKey, theme: themeKey, subTheme: subThemeKey },\n            course: { type: secType, theme: secTheme, subTheme: secSubTheme },\n            matchType: matchType\n          });\n          \n          // Store matched competency info for later use\n          let obj = {};\n          obj[typeKey] = [themeKey]; // Store the original theme, not the course theme\n          this.competencyNotMatchedByCategory.push(obj);\n          seen.add(matchKey);\n          matchedCompetencies.add(themeKey); // Track matched themes\n          isMatched = true;\n          \n          if (counts.hasOwnProperty(typeKey)) {\n            counts[typeKey]++;\n          } else {\n            counts[typeKey] = 1;\n          }\n    \n          counts.total++;\n          break; // Stop looking for matches for this primary competency\n        }\n      }\n    }\n    \n    return counts;\n  }\n  getCompetencyByCategoryNotMatching(categoryType) {\n    // Get all competencies for the given category from role mapping\n    let allCategoryCompetencies = [];\n    for(let i = 0; i < this.planData.competencies.length; i++) {\n      if(this.planData.competencies[i]['type']?.toLowerCase() === categoryType?.toLowerCase()) {\n        allCategoryCompetencies.push(this.planData.competencies[i]['theme']?.toLowerCase().trim());\n      }\n    }\n    \n    // Get matched competencies for this category from courses\n    let matchedCompetencies = [];\n    for(let i = 0; i < this.competencyNotMatchedByCategory.length; i++) {\n      if(this.competencyNotMatchedByCategory[i][categoryType?.toLowerCase()]) {\n        // Extract matched themes from course competencies\n        this.competencyNotMatchedByCategory[i][categoryType?.toLowerCase()].forEach(theme => {\n          if(theme) {\n            matchedCompetencies.push(theme.toLowerCase().trim());\n          }\n        });\n      }\n    }\n    \n    // Enhanced matching: check both theme and subtheme from courses against FRAC competencies\n    // IMPORTANT: Use all available courses for consistent coverage calculation\n    const allCoursesForMatching = this.getAllAvailableCourses();\n    \n    allCoursesForMatching.forEach(course => {\n      // Handle different competency property names\n      let competencies = [];\n      if (course && course.competencies && Array.isArray(course.competencies)) {\n        competencies = course.competencies;\n      } else if (course && course.competencies_v6 && Array.isArray(course.competencies_v6)) {\n        competencies = course.competencies_v6;\n      }\n      \n      competencies.forEach((comp: any) => {\n        let secType = comp?.competencyAreaName?.toLowerCase().trim();\n        if(secType === 'behavioural') secType = 'behavioral';\n        \n        if(secType === categoryType?.toLowerCase()) {\n          const courseTheme = comp.competencyThemeName?.toLowerCase().trim();\n          const courseSubTheme = comp.competencySubThemeName?.toLowerCase().trim();\n          \n          // Check if any FRAC competency matches this course competency\n          for(let i = 0; i < this.planData.competencies.length; i++) {\n            const fracComp = this.planData.competencies[i];\n            if(fracComp['type']?.toLowerCase() === categoryType?.toLowerCase()) {\n              const fracTheme = fracComp['theme']?.toLowerCase().trim();\n              const fracSubTheme = fracComp['sub_theme']?.toLowerCase().trim();\n              \n              // Enhanced cross-matching logic (same as in getMatchedCompetencyStats):\n              // 1. Course Theme vs FRAC Theme\n              // 2. Course Sub Theme vs FRAC Sub Theme  \n              // 3. Course Theme vs FRAC Sub Theme\n              // 4. Course Sub Theme vs FRAC Theme\n              const courseThemeToFracTheme = courseTheme === fracTheme;\n              const courseSubThemeToFracSubTheme = courseSubTheme === fracSubTheme;\n              const courseThemeToFracSubTheme = courseTheme === fracSubTheme;\n              const courseSubThemeToFracTheme = courseSubTheme === fracTheme;\n              \n              if(courseThemeToFracTheme || courseSubThemeToFracSubTheme || \n                 courseThemeToFracSubTheme || courseSubThemeToFracTheme) {\n                \n                let matchType = '';\n                if (courseThemeToFracTheme) matchType = 'CourseTheme-to-FRACTheme';\n                else if (courseSubThemeToFracSubTheme) matchType = 'CourseSubTheme-to-FRACSubTheme';\n                else if (courseThemeToFracSubTheme) matchType = 'CourseTheme-to-FRACSubTheme';\n                else if (courseSubThemeToFracTheme) matchType = 'CourseSubTheme-to-FRACTheme';\n                \n                console.log(`✅ COMPETENCY MATCH FOUND [${matchType}] for ${categoryType}:`, {\n                  course: { theme: courseTheme, subTheme: courseSubTheme },\n                  frac: { theme: fracTheme, subTheme: fracSubTheme },\n                  matchType: matchType\n                });\n                \n                matchedCompetencies.push(fracTheme);\n                break; // Found a match, move to next course competency\n              }\n            }\n          }\n        }\n      });\n    });\n    \n    // Remove duplicates from matched competencies\n    matchedCompetencies = [...new Set(matchedCompetencies)];\n    \n    console.log(`\\n=== ${categoryType.toUpperCase()} COMPETENCY MATCHING ===`);\n    console.log(`${categoryType} - All FRAC competencies:`, allCategoryCompetencies);\n    console.log(`${categoryType} - Matched from courses:`, matchedCompetencies);\n    console.log(`${categoryType} - Match rate: ${matchedCompetencies.length}/${allCategoryCompetencies.length} (${Math.round((matchedCompetencies.length/allCategoryCompetencies.length)*100)}%)`);\n    \n    // Return unmatched competencies (those in role mapping but not covered by courses)\n    return this.compareStringArrays(allCategoryCompetencies, matchedCompetencies);\n  }\n\n  compareStringArrays(arr1: string[], arr2: string[]) {\n    console.log('All competencies in category:', arr1);\n    console.log('Matched competencies from courses:', arr2);\n    \n    // Return items in arr1 that are NOT in arr2 (unmatched competencies)\n    const unmatched = arr1.filter(item => !arr2.includes(item));\n    console.log('Unmatched competencies:', unmatched);\n    \n    return unmatched;\n  }\n  \n  addCourse(missingCompetency?: string, competencyType?: string) {\n    let dialogData = { ...this.planData };\n    \n    // If competency parameters are provided, add them to the dialog data\n    if (missingCompetency && competencyType) {\n      // Parse the theme from the missing competency string (assumes format \"theme-subtheme\" or just \"theme\")\n      const theme = missingCompetency.trim();\n      \n      dialogData.prefillCompetency = {\n        type: competencyType,\n        theme: theme\n      };\n    }\n    \n    const dialogRef = this.dialog.open(AddCourseComponent, {\n      width: '1000px',\n      data: dialogData,\n       panelClass: 'view-cbp-plan-popup',\n      minHeight: '400px',          // Set minimum height\n      maxHeight: '90vh',           // Prevent it from going beyond viewport\n      disableClose: true // Optional: prevent closing with outside click\n    });\n  \n    dialogRef.afterClosed().subscribe(result => {\n      if (result === 'saved') {\n        console.log('Course added successfully! Refreshing data...');\n        \n        // Refresh user courses to include the newly added course\n        this.getUserCourse();\n        \n        // Refresh gap analysis with the latest data\n        setTimeout(() => {\n          this.updateGapAnalysisAfterCoursesUpdate();\n          console.log('Gap analysis refreshed after course addition');\n        }, 500); // Small delay to ensure data is loaded\n      }\n    });\n  }\n\n  filterOnCompetencyTheme(themeItem) {\n    this.selectedThemeFilter = themeItem;\n    let themeName = themeItem?.split(\"-\")[0]?.trim();\n    let subThemeName = themeItem?.split(\"-\")[1]?.trim();\n    \n    console.log('Filtering by theme:', themeName, 'subTheme:', subThemeName, 'Tab index:', this.innerTabActiveIndex);\n    \n    // Get the current competency type based on the active tab\n    let competencyType = '';\n    if(this.innerTabActiveIndex === 1) {\n      competencyType = 'behavioral';\n    } else if(this.innerTabActiveIndex === 2) {\n      competencyType = 'functional';\n    } else if(this.innerTabActiveIndex === 3) {\n      competencyType = 'domain';\n    }\n    \n    // Get all available courses using the helper method\n    const allAvailableCourses = this.getAllAvailableCourses();\n    console.log('Total courses to filter from:', allAvailableCourses.length);\n    \n    this.filterdCourses = allAvailableCourses.filter(course => {\n      if (!course) return false;\n      \n      // Handle different competency property names\n      let competencies = [];\n      if (course.competencies && Array.isArray(course.competencies)) {\n        competencies = course.competencies;\n      } else if (course.competencies_v6 && Array.isArray(course.competencies_v6)) {\n        competencies = course.competencies_v6;\n      }\n      \n      if (competencies.length === 0) return false;\n      \n      // Filter by competency type and theme/subtheme\n      return competencies.some(comp => {\n        if (!comp) return false;\n        \n        // Check competency type matches current tab\n        let compType = comp?.competencyAreaName?.toLowerCase();\n        if (compType === 'behavioural') compType = 'behavioral'; // Normalize spelling\n        \n        if (compType !== competencyType) return false;\n        \n        // Check cross-matching like gap analysis: theme vs subtheme and subtheme vs theme\n        const compTheme = comp?.competencyThemeName?.toLowerCase()?.trim();\n        const compSubTheme = comp?.competencySubThemeName?.toLowerCase()?.trim();\n        const searchTheme = themeName?.toLowerCase();\n        const searchSubTheme = subThemeName?.toLowerCase();\n        \n        // Enhanced cross-matching logic like gap analysis:\n        // 1. Selected Theme vs Course Theme\n        // 2. Selected Sub Theme vs Course Sub Theme  \n        // 3. Selected Theme vs Course Sub Theme\n        // 4. Selected Sub Theme vs Course Theme\n        const themeToThemeMatch = searchTheme && compTheme === searchTheme;\n        const subThemeToSubThemeMatch = searchSubTheme && compSubTheme === searchSubTheme;\n        const themeToSubThemeMatch = searchTheme && compSubTheme === searchTheme;\n        const subThemeToThemeMatch = searchSubTheme && compTheme === searchSubTheme;\n        \n        const isMatch = themeToThemeMatch || subThemeToSubThemeMatch || themeToSubThemeMatch || subThemeToThemeMatch;\n        \n        // Log matches for debugging (similar to gap analysis)\n        if (isMatch) {\n          let matchType = '';\n          if (themeToThemeMatch) matchType = 'Theme-to-Theme';\n          else if (subThemeToSubThemeMatch) matchType = 'SubTheme-to-SubTheme';\n          else if (themeToSubThemeMatch) matchType = 'Theme-to-SubTheme';\n          else if (subThemeToThemeMatch) matchType = 'SubTheme-to-Theme';\n          \n          console.log(`✅ FILTER MATCH FOUND [${matchType}]:`, {\n            selected: { theme: searchTheme, subTheme: searchSubTheme },\n            course: { type: compType, theme: compTheme, subTheme: compSubTheme },\n            matchType: matchType\n          });\n        }\n        \n        // Match if any of the cross-matching conditions are met\n        return isMatch;\n      });\n    });\n    \n    console.log('Filtered courses for theme:', themeName, 'Count:', this.filterdCourses.length);\n    console.log('Filtered courses:', this.filterdCourses.map(c => c.name || c.course));\n  }\n  \n  clearThemeFilter() {\n    this.selectedThemeFilter = '';\n    // Reset to category filtered courses by calling the tab change method\n    this.onInnerTabChange({ \n      index: this.innerTabActiveIndex, \n      tab: { textLabel: this.innerTabActiveText } \n    } as any);\n    console.log('Theme filter cleared, showing all courses for category:', this.innerTabActiveText);\n  }\n  \n  isThemeSelected(theme: string): boolean {\n    return this.selectedThemeFilter === theme;\n  }\n\n  /**\n   * Add course for the currently selected theme filter with prefilled competency data\n   */\n  addCourseForSelectedTheme() {\n    if (!this.selectedThemeFilter) {\n      console.warn('No theme selected for adding course');\n      return;\n    }\n\n    // Parse theme and sub-theme from selectedThemeFilter (format: \"Theme - SubTheme\")\n    const themeParts = this.selectedThemeFilter.split('-');\n    const theme = themeParts[0]?.trim();\n    const subTheme = themeParts[1]?.trim();\n\n    // Get the current competency type based on the active tab\n    // Map the tab labels to the format expected by AddCourseComponent\n    let competencyType = '';\n    if (this.innerTabActiveIndex === 1) {\n      competencyType = 'Behavioral'; // Tab label is \"behavioural\"\n    } else if (this.innerTabActiveIndex === 2) {\n      competencyType = 'Functional'; // Tab label is \"functional\"\n    } else if (this.innerTabActiveIndex === 3) {\n      competencyType = 'Domain'; // Tab label is \"domain\"\n    }\n\n    console.log('Tab mapping - innerTabActiveIndex:', this.innerTabActiveIndex, \n                'innerTabActiveText:', this.innerTabActiveText, \n                'mapped competencyType:', competencyType);\n\n    console.log('Adding course for missing competency:', {\n      competencyType,\n      theme,\n      subTheme,\n      selectedThemeFilter: this.selectedThemeFilter\n    });\n\n    // Create dialog data with prefilled competency information\n    let dialogData = { ...this.planData };\n    dialogData.prefillCompetency = {\n      type: competencyType,\n      theme: theme,\n      subTheme: subTheme || '' // Include sub-theme if available\n    };\n\n    const dialogRef = this.dialog.open(AddCourseComponent, {\n      width: '800px',\n      data: dialogData,\n      panelClass: 'view-cbp-plan-popup',\n      minHeight: '400px',\n      maxHeight: '90vh',\n      disableClose: true\n    });\n\n    dialogRef.afterClosed().subscribe(result => {\n      if (result === 'saved') {\n        console.log('Course added successfully for competency! Refreshing data...');\n        \n        // Refresh user courses to include the newly added course\n        this.getUserCourse();\n        \n        // Update gap analysis after course addition\n        this.updateGapAnalysisAfterCoursesUpdate();\n      }\n    });\n  }\n\n  getDuration(time:any) {\n    return this.sharedService.convert(time);\n  }\n\n\n  getBehaviouralMatched() {\n    this.behaviouralMatched = []\n    console.log('this.planData.competencies', this.planData)\n    console.log('this.behaviouralNotMatched', this.behaviouralNotMatched)\n    this.planData.competencies.map((item)=>{\n      if(item && item?.type === 'Behavioral' && this.behaviouralNotMatched.indexOf(item?.theme?.toLowerCase()) < 0) {\n        this.behaviouralMatched.push(item)\n      }\n    })\n\n    console.log('this.behaviouralMatched--', this.behaviouralMatched)\n  }\n\n  getFunctionalMatched() {\n    this.functionalMatched = []\n    this.planData.competencies.map((item)=>{\n      if(item && item?.type === 'Functional' && this.functionalNotMatched.indexOf(item?.theme?.toLowerCase()) < 0) {\n        this.functionalMatched.push(item)\n      }\n    })\n    return this.functionalMatched\n  }\n\n  getDomainMatched() {\n    this.domainMatched = []\n    this.planData.competencies.map((item)=>{\n      if(item && item?.type === 'Domain' && this.domainNotMatched.indexOf(item?.theme?.toLowerCase()) < 0) {\n        this.domainMatched.push(item)\n      }\n    })\n    console.log('this.domainMatched--', this.domainMatched)\n  }\n\n  downloadPDF() {\n    this.isPDFDownload = true\n    this.loading = true\n    const element = this.pdfContent.nativeElement;\n\n  // Wait for images to load\n  const images = element.querySelectorAll('img');\n  const promises = Array.from(images).map((img: HTMLImageElement) => {\n    if (img.complete) return Promise.resolve();\n    return new Promise(resolve => img.onload = resolve);\n  });\n\n  Promise.all(promises).then(() => {\n    const options = {\n      margin: 0.20,\n      filename: 'Gap Analysis.pdf',\n      image: { type: 'jpeg', quality: 0.98 },\n      html2canvas: {\n        scale: 2,\n        useCORS: true,\n        scrollY: 0,\n      },\n      jsPDF: {\n        unit: 'in',\n        format: 'a4',\n        orientation: 'portrait'\n      },\n      pagebreak: {\n        mode: ['css', 'legacy'],\n        before: '.page-break',\n        avoid: ['.no-break']\n      }\n    };\n\n    html2pdf().from(element).set(options).save()\n    setTimeout(() => {\n      this.isPDFDownload = false\n      this.loading = false;\n    }, 3000); \n  });\n  }\n\n\n  redirectToToc(item) {\n    if(item?.public_link) {\n      window.open(item?.public_link, '_blank')\n    } else {\n      let url = `https://portal.igotkarmayogi.gov.in/app/toc/${item?.identifier}/overview?`\n    window.open(url, '_blank')\n    }\n    \n  }\n\n  /**\n   * Initialize gap analysis stats after initial data load\n   */\n  initializeGapAnalysisStats() {\n    // Set a small timeout to ensure all async operations complete\n    setTimeout(() => {\n      if (this.filterdCourses && this.filterdCourses.length > 0) {\n        this.gapAnalysisStats();\n      }\n    }, 100);\n  }\n\n  /**\n   * Update gap analysis stats after courses are updated (like suggested courses added)\n   */\n  updateGapAnalysisAfterCoursesUpdate() {\n    // Don't modify originalData - it should remain as AI recommended courses only\n    // The gap analysis already properly includes all course types\n    \n    // Recalculate gap analysis stats\n    this.gapAnalysisStats();\n  }\n\n  /**\n   * Regenerate course recommendations by deleting existing recommendations and generating new ones\n   */\n  async regenerateCourseRecommendations() {\n    if (this.isRegenerating) {\n      return; // Prevent multiple simultaneous regenerations\n    }\n\n    try {\n      this.isRegenerating = true;\n      \n      // Show confirmation dialog\n      const confirmed = await this.showConfirmationDialog();\n      \n      if (!confirmed) {\n        this.isRegenerating = false;\n        return;\n      }\n\n      console.log('Starting course recommendation regeneration...');\n      \n      // Set regeneration progress state\n      this.isRegeneratingWithProgress = true;\n      this.dataLoaded = false; // Hide main content during regeneration\n      \n      // Step 1: Delete existing course recommendations\n      await this.deleteCourseRecommendations();\n      \n      // Step 2: Generate new course recommendations\n      await this.generateNewCourseRecommendations();\n      \n      // Step 3: Refresh the current data\n      this.refreshComponent();\n      \n      console.log('Course recommendation regeneration completed successfully');\n      \n      // Show success message\n      this.snackBar.open('Course recommendations regenerated successfully!', 'Close', {\n        duration: 5000,\n        panelClass: ['success-snackbar']\n      });\n      \n    } catch (error) {\n      console.error('Error during course recommendation regeneration:', error);\n      \n      // Show error message\n      this.snackBar.open('Failed to regenerate course recommendations. Please try again.', 'Close', {\n        duration: 5000,\n        panelClass: ['error-snackbar']\n      });\n    } finally {\n      this.isRegenerating = false;\n      this.isRegeneratingWithProgress = false;\n      this.dataLoaded = true; // Ensure main content is shown after regeneration\n    }\n  }\n\n  /**\n   * Show confirmation dialog for regenerate action\n   */\n  private showConfirmationDialog(): Promise<boolean> {\n    return new Promise((resolve) => {\n      // Create a custom confirmation dialog\n      const dialogRef = this.dialog.open(RegenerateConfirmationDialog, {\n        width: '450px',\n        panelClass: 'regenerate-confirmation-dialog',\n        disableClose: true\n      });\n\n      dialogRef.afterClosed().subscribe(result => {\n        resolve(result === true);\n      });\n    });\n  }\n\n  /**\n   * Delete existing course recommendations for the current role mapping\n   */\n  private deleteCourseRecommendations(): Promise<any> {\n    return new Promise((resolve, reject) => {\n      const roleMapId = this.planData?.id;\n      \n      if (!roleMapId) {\n        reject(new Error('Role mapping ID not found'));\n        return;\n      }\n\n      console.log('Deleting course recommendations for role mapping:', roleMapId);\n      \n      this.sharedService.deleteCourseRecommendations(roleMapId).subscribe({\n        next: (response) => {\n          console.log('Course recommendations deleted successfully:', response);\n          resolve(response);\n        },\n        error: (error) => {\n          console.error('Error deleting course recommendations:', error);\n          reject(error);\n        }\n      });\n    });\n  }\n\n  /**\n   * Generate new course recommendations during regeneration\n   */\n  private generateNewCourseRecommendations(): Promise<any> {\n    console.log('Generating new course recommendations...');\n    return this.getRecommendedCourseForRegeneration(this.planData.id);\n  }\n\n  /**\n   * Enhanced course generation specifically for regeneration with progressive loading\n   */\n  private getRecommendedCourseForRegeneration(role_mapping_id: string): Promise<any> {\n    return new Promise((resolve, reject) => {\n      // Start the progressive loading simulation for regeneration\n      this.startRegenerativeProgressiveLoading();\n      \n      // Make the actual API call\n      // this.sharedService.getRecommendedCourse(role_mapping_id).subscribe({\n      //   next: (response) => {\n      //     // Stop progressive loading and show completion\n      //     this.isRegeneratingWithProgress = false; // This will stop the interval\n      //     this.progressPercentage = 100;\n      //     this.currentProcessingStage = 'Course recommendations regenerated successfully!';\n          \n      //     // Clear the loading state after showing completion\n      //     setTimeout(() => {\n      //       this.currentProcessingStage = '';\n      //       this.progressPercentage = 0;\n      //       resolve(response);\n      //     }, 2000);\n      //   },\n      //   error: (error) => {\n      //     // Stop progressive loading\n      //     this.isRegeneratingWithProgress = false;\n      //     this.currentProcessingStage = '';\n      //     this.progressPercentage = 0;\n          \n      //     // Handle specific error cases\n      //     if (error.status === 409 || error.error?.detail?.includes('already exists')) {\n      //       // Course recommendations already exist - this is normal\n      //       console.log('Course recommendations already exist, loading existing data...');\n            \n      //       this.currentProcessingStage = 'Loading existing course recommendations...';\n            \n      //       // Try to get existing data\n      //       this.sharedService.getRecommendedCourse(role_mapping_id).subscribe({\n      //         next: (existingResponse) => {\n      //           console.log('Successfully loaded existing course recommendations');\n      //           this.progressPercentage = 100;\n      //           this.currentProcessingStage = 'Loaded existing course recommendations successfully!';\n                \n      //           setTimeout(() => {\n      //             this.currentProcessingStage = '';\n      //             this.progressPercentage = 0;\n      //             resolve(existingResponse);\n      //           }, 2000);\n      //         },\n      //         error: (loadError) => {\n      //           console.error('Failed to load existing course recommendations:', loadError);\n      //           this.currentProcessingStage = '';\n      //           this.progressPercentage = 0;\n      //           reject(loadError);\n      //         }\n      //       });\n      //     } else {\n      //       console.error('Error during course recommendation regeneration:', error);\n      //       reject(error);\n      //     }\n      //   }\n      // });\n      this.isRegeneratingWithProgress = true;\n      this.progressPercentage = 0;\n      this.currentProcessingStage = 'Generating course recommendations...';\n  \n      interval(5000)\n        .pipe(\n          switchMap(() =>\n            this.sharedService.getRecommendedCourse(role_mapping_id).pipe(\n              catchError(error => {\n                // Pass error through observable so polling logic can inspect it\n                return of({ error });\n              })\n            )\n          ),\n  \n          tap(res => console.log(\"Polling result:\", res)),\n  \n          /**\n           * ⬇️ STOP POLLING only when:\n           * - SUCCESS → res.status === COMPLETED\n           * - ERROR → conflict / already exists\n           */\n          takeWhile(res => {\n            if (res?.status === 'COMPLETED') return false;       // Stop\n            if (res?.error?.status === 409) return false;        // Stop\n            if (res?.error?.error?.detail?.includes('already exists')) return false; // Stop\n            return true; // Keep polling\n          }, true) // include final emission\n        )\n        .subscribe({\n          next: (res) => {\n            /** -------------------------------\n             *  SUCCESS CASE (status COMPLETED)\n             -------------------------------- */\n            if (res?.status === 'COMPLETED') {\n              this.isRegeneratingWithProgress = false;\n              this.progressPercentage = 100;\n              this.currentProcessingStage = 'Course recommendations regenerated successfully!';\n  \n              setTimeout(() => {\n                this.currentProcessingStage = '';\n                this.progressPercentage = 0;\n                resolve(res);\n              }, 2000);\n  \n              return;\n            }\n  \n            /** -----------------------------------\n             *  ERROR CASE (409 / already exists)\n             ------------------------------------ */\n            if (res?.error) {\n              const error = res.error;\n  \n              if (error.status === 409 || error?.error?.detail?.includes('already exists')) {\n  \n                this.currentProcessingStage = 'Loading existing course recommendations...';\n  \n                this.sharedService.getRecommendedCourse(role_mapping_id).subscribe({\n                  next: (existingData) => {\n                    this.progressPercentage = 100;\n                    this.currentProcessingStage = 'Loaded existing course recommendations successfully!';\n  \n                    setTimeout(() => {\n                      this.currentProcessingStage = '';\n                      this.progressPercentage = 0;\n                      resolve(existingData);\n                    }, 2000);\n                  },\n                  error: loadError => reject(loadError)\n                });\n  \n                return;\n              }\n  \n              /** Any other error → stop & reject */\n              this.isRegeneratingWithProgress = false;\n              this.currentProcessingStage = '';\n              this.progressPercentage = 0;\n              reject(error);\n              return;\n            }\n  \n            /** ------------------------------\n             *  STILL PROCESSING (keep polling)\n             ------------------------------- */\n            this.progressPercentage = Math.min(this.progressPercentage + 10, 95);\n            this.currentProcessingStage = 'Still processing course recommendations...';\n          },\n  \n          error: err => reject(err)\n        });\n    });\n  }\n\n \n\n  // Progressive loading methods for regeneration\n  startRegenerativeProgressiveLoading() {\n    this.currentProcessingStage = this.processingStages[0];\n    this.progressPercentage = 0;\n    this.stageStartTime = Date.now();\n    this.simulateRegenerativeProgressiveStages();\n  }\n\n  simulateRegenerativeProgressiveStages() {\n    let currentStageIndex = 0;\n    const totalDuration = 60000; // 60 seconds estimated duration\n    const stageInterval = totalDuration / this.processingStages.length;\n    \n    const progressInterval = setInterval(() => {\n      // Stop if regeneration is complete\n      if (!this.isRegeneratingWithProgress) {\n        clearInterval(progressInterval);\n        return;\n      }\n      \n      const elapsed = Date.now() - this.stageStartTime;\n      const currentStageProgress = (elapsed % stageInterval) / stageInterval;\n      const stageIndex = Math.min(Math.floor(elapsed / stageInterval), this.processingStages.length - 1);\n      \n      // Update stage if needed\n      if (stageIndex !== currentStageIndex && stageIndex < this.processingStages.length) {\n        currentStageIndex = stageIndex;\n        this.currentProcessingStage = this.processingStages[stageIndex];\n      }\n      \n      // Calculate overall progress (each stage is worth ~16.67%)\n      const baseProgress = (stageIndex / this.processingStages.length) * 100;\n      const stageProgress = (currentStageProgress / this.processingStages.length) * 100;\n      this.progressPercentage = Math.min(Math.round(baseProgress + stageProgress), 95);\n    }, 1000);\n  }\n\n  /**\n   * Refresh the component data after regeneration\n   */\n  private refreshComponent() {\n    console.log('Refreshing component data...');\n    \n    // Reset all filters and selections\n    this.selectedThemeFilter = '';\n    this.selectFilterCourses = [];\n    this.filterdCourses = [];\n    this.originalFilteredCourses = [];\n    this.suggestedCourses = [];\n    this.userAddedCourses = [];\n    \n    // Reset tab states\n    this.innerTabActiveIndex = 0;\n    this.outerTabActiveIndex = 0;\n    \n    // Call the data loading methods directly to avoid resetting dataLoaded\n    this.loadComponentData();\n  }\n\n  /**\n   * Load component data (separated from ngOnInit for reuse)\n   */\n  private loadComponentData() {\n    this.getRecommendedCourseWithProgress(this.planData.id).then((res) => {\n      console.log('res', res)\n      this.recommended_course_id = res.id\n      let allCoures = []\n      if (res && res.filtered_courses && res.filtered_courses.length) {\n        res?.filtered_courses.forEach((item) => {\n          if (item?.relevancy >= 85) {\n            allCoures.push(item)\n          }\n        })\n        this.originalData = allCoures\n        this.filterdCourses = allCoures\n      }\n\n      console.log('this.filterdCourses', this.filterdCourses)\n      this.getCourses()\n      this.getSuggestedCourse()\n      \n      // Initialize gap analysis stats after courses are loaded\n      this.initializeGapAnalysisStats()\n      this.getUserCourse()\n      \n      // Mark data as loaded after all initial operations\n      this.dataLoaded = true;\n    }).catch((error) => {\n      console.error('Error getting recommended courses:', error);\n      if (error.status === 401) {\n        console.log('Unauthorized access - user will be redirected to login');\n      } else if (error.status !== 409) {\n        // Don't log error for 409 (already exists) as it's handled in the method\n        console.error('Failed to load course recommendations');\n      }\n      // Mark data as loaded even if there's an error to show the dialog content\n      this.dataLoaded = true;\n    });\n  }\n\n  // Progressive loading methods for course generation\n  startProgressiveLoading() {\n    this.currentProcessingStage = this.processingStages[0];\n    this.progressPercentage = 0;\n    this.stageStartTime = Date.now();\n    this.simulateProgressiveStages();\n  }\n\n  simulateProgressiveStages() {\n    let currentStageIndex = 0;\n    const totalDuration = 60000; // 60 seconds estimated duration\n    const stageInterval = totalDuration / this.processingStages.length;\n    \n    const progressInterval = setInterval(() => {\n      const elapsed = Date.now() - this.stageStartTime;\n      const currentStageProgress = (elapsed % stageInterval) / stageInterval;\n      const stageIndex = Math.min(Math.floor(elapsed / stageInterval), this.processingStages.length - 1);\n      \n      // Update stage if needed\n      if (stageIndex !== currentStageIndex && stageIndex < this.processingStages.length) {\n        currentStageIndex = stageIndex;\n        this.currentProcessingStage = this.processingStages[stageIndex];\n      }\n      \n      // Calculate overall progress (each stage is worth ~16.67%)\n      const baseProgress = (stageIndex / this.processingStages.length) * 100;\n      const stageProgress = (currentStageProgress / this.processingStages.length) * 100;\n      this.progressPercentage = Math.min(Math.round(baseProgress + stageProgress), 95);\n      \n      // Clear interval when loading stops\n      if (!this.loading) {\n        clearInterval(progressInterval);\n        this.progressPercentage = 100;\n        this.currentProcessingStage = 'Course recommendations generated successfully!';\n      }\n    }, 1000);\n  }\n\n  // Enhanced course generation with progressive loading\n  getRecommendedCourseWithProgress(role_mapping_id: string): Promise<any> {\n    return new Promise((resolve, reject) => {\n      this.loading = true;\n      this.currentProcessingStage = 'Generating course recommendations...';\n      this.progressPercentage = 30;\n      this.startProgressiveLoading();\n      \n      interval(5000) // ⏱ poll every 5 seconds\n      .pipe(\n        tap(() => {\n          this.currentProcessingStage = 'Processing...';\n        }),\n        switchMap(() => this.sharedService.getRecommendedCourse(role_mapping_id)),\n\n        // Continue polling while status !== COMPLETED\n        takeWhile((response: any) => response?.status !== 'COMPLETED', true),\n\n        finalize(() => {\n          this.loading = false;\n        })\n      )\n      .subscribe({\n        next: (response: any) => {\n          if (response?.status === 'COMPLETED') {\n\n            this.progressPercentage = 100;\n            this.currentProcessingStage = 'Course recommendations generated successfully!';\n\n            setTimeout(() => {\n              this.currentProcessingStage = '';\n              this.progressPercentage = 0;\n            }, 2000);\n\n            this.snackBar.open('Recommendations ready!', 'X', {\n              duration: 3000,\n              panelClass: ['snackbar-success']\n            });\n\n            resolve(response);\n          }\n        },\n\n        error: (error) => {\n          this.loading = false;\n          this.currentProcessingStage = '';\n          this.progressPercentage = 0;\n\n          if (error.status === 409 || error.error?.detail?.includes('already exists')) {\n            this.snackBar.open('Course recommendations already exist.', 'X', {\n              duration: 3000,\n              panelClass: ['snackbar-success']\n            });\n\n            resolve(null); // not a real error\n          } else {\n            this.snackBar.open('Failed to generate course recommendations.', 'X', {\n              duration: 3000,\n              panelClass: ['snackbar-error']\n            });\n            reject(error);\n          }\n        }\n      });\n    });\n  }\n\n  resetFilters(): void {\n    this.filterForm.reset({\n      competency: [],\n      rating: [],\n      language: [],\n      duration: [],\n      provider: []\n    });\n  \n    // Reset filtered dropdown lists\n    this.filteredCompetency = [...this.competenciesType];\n    this.filteredRatings = [...this.ratings];\n    this.filteredLanguages = [...this.languages];\n    this.filteredDurations = [...this.durations];\n    this.filteredProviders = [...this.providers];\n  \n    // Reset course list\n    this.filterdCourses = [...this.fullCourseList];\n    // this.fullCourseList.forEach((item)=>{\n    //   if(item && item.organisation && item.organisation.length) {\n    //     if(this.filteredProviders.indexOf(item.organisation[0]) < 0) {\n    //       this.filteredProviders.push(item.organisation[0])\n    //     }\n        \n    //   }\n    // })\n    this.getAllAvailableCourses()\n  }\n\n  filterList(value: string, type: string) {\n    const search = value.toLowerCase();\n\n    switch (type) {\n      case 'competency':\n        this.filteredCompetency = this.competenciesType.filter(v => v.toLowerCase().includes(search));\n        break;\n      case 'rating':\n        this.filteredRatings = this.ratings.filter(v => v.toLowerCase().includes(search));\n        break;\n      case 'language':\n        this.filteredLanguages = this.languages.filter(v => v.toLowerCase().includes(search));\n        break;\n      case 'duration':\n        this.filteredDurations = this.durations.filter(v => v.toLowerCase().includes(search));\n        break;\n      case 'provider':\n        this.filteredProviders = this.providers.filter(v => v.toLowerCase().includes(search));\n        break;\n    }\n  }\n\n  normalizeCompetency(value: string): string {\n    if (!value) return '';\n    const v = value.toLowerCase();\n  \n    if (v === 'all') return 'all';\n    if (v.includes('behavioural') || v.includes('behavioral')) return 'behavioral';\n    if (v.includes('functional')) return 'functional';\n    if (v.includes('domain')) return 'domain';\n  \n    return '';\n  }\n\n  applyFilters(): void {\n    const {\n      competency = [],\n      rating = [],\n      language = [],\n      duration = [],\n      provider = []\n    } = this.filterForm.value;\n\n    console.log('this.fullCourseList--',this.fullCourseList)\n  \n    this.filterdCourses = this.fullCourseList.filter(course => {\n  \n      /* ---------------- Competency ---------------- */\n      const courseCompetencies = [\n        ...(course.competencies || []),\n        ...(course.competencies_v6 || [])\n      ];\n  \n      const selectedCompetencies = competency\n        .map((c: string) => this.normalizeCompetency(c))\n        .filter(c => c !== '');\n\n      const competencyMatch =\n        selectedCompetencies.length === 0 ||\n        selectedCompetencies.includes('all') ||\n        courseCompetencies.some((c: any) =>\n          selectedCompetencies.includes(\n            this.normalizeCompetency(c.competencyAreaName)\n          )\n        );\n  \n      /* ---------------- Rating ---------------- */\n      const ratingMatch =\n        rating.length === 0 ||\n        this.matchRating(course, rating);\n  \n      /* ---------------- Language ---------------- */\n      const languageMatch =\n        language.length === 0 ||\n        language.some((l: string) =>\n          course.language === l ||\n          course.language?.includes?.(l) ||\n          course.language?.[0]?.includes?.(l)\n        );\n  \n      /* ---------------- Duration ---------------- */\n      const durationMatch =\n        duration.length === 0 ||\n        this.matchDuration(course.duration, duration);\n  \n      /* ---------------- Provider ---------------- */\n      const providerMatch =\n        provider.length === 0 ||\n        provider.some((p: string) =>\n          course.organisation?.includes(p)\n        );\n  \n      return (\n        competencyMatch &&\n        ratingMatch &&\n        languageMatch &&\n        durationMatch &&\n        providerMatch\n      );\n    });\n  }\n\n  matchRating(course: any, selectedRatings: string[]): boolean {\n    if (!selectedRatings || selectedRatings.length === 0) {\n      return true; // no filter selected → match everything\n    }\n  \n    let rating = null;\n  \n    // 1️⃣ Use avgRating if available\n    if (course.avgRating != null && !isNaN(course.avgRating)) {\n      rating = Number(course.avgRating);\n    } \n    // 2️⃣ Map relevancy if avgRating missing\n    else if (course.relevancy != null && !isNaN(course.relevancy)) {\n      const rel = Number(course.relevancy);\n      if (rel >= 90) rating = 4.5;\n      else if (rel >= 80) rating = 4.0;\n      else if (rel >= 70) rating = 3.5;\n      else if (rel >= 50) rating = 2.5;\n      else rating = 1.0;\n    }\n  \n    // 3️⃣ No usable rating → exclude\n    if (rating === null) return false;\n  \n    // 4️⃣ Match selected rating ranges\n    return selectedRatings.some(r => {\n      switch (r) {\n        case '4.5 and above': return rating >= 4.5;\n        case '4.0 and above': return rating >= 4.0;\n        case '3.5 and above': return rating >= 3.5;\n        case '2.5 and above': return rating >= 2.5;\n        case '1 and above': return rating >= 1.0;\n        default: return false;\n      }\n    });\n  }\n  \n\n  matchDuration(durationInSeconds: number | string, selectedRanges: string[]): boolean {\n    const hours = Number(durationInSeconds) / 3600;\n  \n    return selectedRanges.some(range => {\n      switch (range) {\n        case '< 1 Hour':\n          return hours < 1;\n        case '1-5 Hours':\n          return hours >= 1 && hours <= 5;\n        case '5+ Hours':\n          return hours > 5;\n        default:\n          return true;\n      }\n    });\n  }\n}\n\n// Confirmation Dialog Component\n@Component({\n  selector: 'regenerate-confirmation-dialog',\n  template: `\n    <div class=\"confirmation-dialog-container\">\n      <div class=\"dialog-header\">\n        <mat-icon class=\"warning-icon\">refresh</mat-icon>\n        <h2 mat-dialog-title>Regenerate Course Recommendations</h2>\n      </div>\n      \n      <mat-dialog-content class=\"dialog-content\">\n        <p class=\"main-message\">\n          This will delete all current course recommendations and generate new ones based on the latest role mapping.\n        </p>\n        <p class=\"sub-message\">\n          Are you sure you want to continue?\n        </p>\n      </mat-dialog-content>\n      \n      <mat-dialog-actions class=\"dialog-actions\">\n        <button mat-button (click)=\"onCancel()\" class=\"cancel-btn\">\n          Cancel\n        </button>\n        <button mat-raised-button color=\"primary\" (click)=\"onConfirm()\" class=\"confirm-btn\">\n          <mat-icon>refresh</mat-icon>\n          Yes, Regenerate\n        </button>\n      </mat-dialog-actions>\n    </div>\n  `,\n  styles: [`\n    .confirmation-dialog-container {\n      padding: 0;\n    }\n    \n    .dialog-header {\n      display: flex;\n      align-items: center;\n      gap: 12px;\n      padding: 24px 24px 16px 24px;\n      border-bottom: 1px solid #e0e0e0;\n    }\n    \n    .warning-icon {\n      font-size: 24px;\n      width: 24px;\n      height: 24px;\n      color: #ff9800;\n    }\n    \n    h2 {\n      margin: 0;\n      font-size: 18px;\n      font-weight: 600;\n      color: #333;\n    }\n    \n    .dialog-content {\n      padding: 24px;\n    }\n    \n    .main-message {\n      font-size: 16px;\n      color: #333;\n      margin: 0 0 12px 0;\n      line-height: 1.5;\n    }\n    \n    .sub-message {\n      font-size: 14px;\n      color: #666;\n      margin: 0;\n      font-weight: 500;\n    }\n    \n    .dialog-actions {\n      padding: 16px 24px 24px 24px;\n      gap: 12px;\n      justify-content: flex-end;\n    }\n    \n    .cancel-btn {\n      color: #666;\n    }\n    \n    .confirm-btn {\n      display: flex;\n      align-items: center;\n      gap: 8px;\n      \n      .mat-icon {\n        font-size: 18px;\n        width: 18px;\n        height: 18px;\n        margin: 0;\n      }\n    }\n  `]\n})\nexport class RegenerateConfirmationDialog {\n  constructor(\n    public dialogRef: MatDialogRef<RegenerateConfirmationDialog>\n  ) {}\n\n  onCancel(): void {\n    this.dialogRef.close(false);\n  }\n\n  onConfirm(): void {\n    this.dialogRef.close(true);\n  }\n\n \n}\n","<div class=\"view-cbp-plan\">\n    <div class=\"popup-container\">\n        \n        <!-- Initial Loading Screen (for initial load and regeneration) -->\n        <div class=\"initial-loading-container\" *ngIf=\"!dataLoaded || isRegeneratingWithProgress\">\n            <div class=\"loading-content\">\n                <mat-spinner diameter=\"50\"></mat-spinner>\n                <div class=\"loading-text mt-3\">\n                    <p class=\"main-message\">{{ currentProcessingStage || (isRegeneratingWithProgress ? 'Regenerating course recommendations...' : 'Loading course recommendations...') }}</p>\n                    <div class=\"progress-details\" *ngIf=\"progressPercentage > 0\">\n                        <div class=\"progress-indicator\">\n                            <div class=\"progress-bar-container\">\n                                <div class=\"progress-bar\" \n                                     [style.width.%]=\"progressPercentage\">\n                                </div>\n                            </div>\n                            <small class=\"progress-text\">{{ progressPercentage }}% Complete</small>\n                        </div>\n                        <small class=\"time-estimate\">\n                            Real-time course generation in progress. This may take 1-2 minutes.\n                        </small>\n                    </div>\n                </div>\n            </div>\n        </div>\n\n        <!-- Main Content -->\n        <div class=\"main-content\" *ngIf=\"dataLoaded && !isRegeneratingWithProgress\">\n        <div class=\"popup-header\">\n            <div class=\"header-left\">\n                <div class=\"heading\">Save Courses (<span>{{sharedService?.cbpPlanFinalObj?.ministry?.orgName}} <span\n                            *ngIf=\"planData?.designation_name \">/ {{planData?.designation_name}}</span></span>)</div>\n            </div>\n            <div class=\"header-actions\">\n                <button class=\"regenerate-btn\" (click)=\"regenerateCourseRecommendations()\"\n                        [disabled]=\"isRegenerating\"\n                        mat-raised-button color=\"primary\">\n                    <mat-icon *ngIf=\"!isRegenerating\">refresh</mat-icon>\n                    <mat-spinner *ngIf=\"isRegenerating\" diameter=\"20\"></mat-spinner>\n                    <span>{{isRegenerating ? 'Regenerating...' : 'Regenerate Recommendations'}}</span>\n                </button>\n                <div class=\"cursor-pointer close-btn\" (click)=\"closeDialog()\">\n                    <mat-icon>close</mat-icon>\n                </div>\n            </div>\n        </div>\n        <div class=\"section-container mt-4\">\n            <mat-tab-group (selectedTabChange)=\"onOuterTabChange($event)\">\n                <!-- First Main Tab -->\n                <mat-tab label=\"course recommendation\">\n                    <!-- Nested Tabs -->\n                    <!-- <mat-tab-group (selectedTabChange)=\"onInnerTabChange($event)\">\n                        <mat-tab label=\"all\">\n\n                        </mat-tab>\n                        <mat-tab label=\"behavioural\">\n\n                        </mat-tab>\n                        <mat-tab label=\"functional\">\n\n                        </mat-tab>\n                        <mat-tab label=\"domain\">\n\n                        </mat-tab>\n                    </mat-tab-group> -->\n                </mat-tab>\n\n                <!-- Second Main Tab -->\n                <mat-tab label=\"gap analysis\">\n                    <!-- <p>Gap analysis content goes here</p> -->\n                </mat-tab>\n            </mat-tab-group>\n            <form [formGroup]=\"filterForm\" class=\"filters-container\">\n            <div class=\"role-mapping-container\"\n                *ngIf=\"outerTabActiveIndex === 0 && (innerTabActiveIndex === 0 || innerTabActiveIndex === 1 || innerTabActiveIndex === 2 || innerTabActiveIndex === 3 )\">\n                <div class=\"container\">\n                    <div class=\"section-header-improved mt-3\">\n                        <div class=\"search-and-buttons-container\">\n                            <div>\n                                <label>Search Courses</label>\n                            </div>                            \n                            <div class=\"search-container-compact\">\n                                <div class=\"rsearch\">\n                                    <mat-icon class=\"search-icon\">search</mat-icon>\n                                    <input class=\"sinput-compact\" [(ngModel)]=\"searchText\"\n                                           (input)=\"applyFilter($event.target.value);\"\n                                           placeholder=\"Search Courses\" type=\"text\">\n                                </div>\n                            </div>\n                            \n                        </div>\n                        \n\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Competency</label>\n                            </div>   \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.competency?.length ? '' : 'Competency' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"competency\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                        \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Competency\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'competency')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredCompetency\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>                       \n                            \n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Rating</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.rating?.length ? '' : 'Rating' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"rating\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Reatings\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'rating')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredRatings\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                       \n                      \n                        \n                        \n                    </div>\n                    <div class=\"section-header-improved-sec-2 mt-4\">\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Language</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.language?.length ? '' : 'Language' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"language\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Languages\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'language')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredLanguages\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Duration</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.duration?.length ? '' : 'Duration' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"duration\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Duration\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'duration')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredDurations\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div class=\"search-and-buttons-container\">\n                            <div style=\"margin-left: 10px;\">\n                                <label>Select Provider</label>\n                            </div>                            \n                            <div>\n                                <mat-form-field appearance=\"outline\">\n                                    <mat-label>\n                                        {{ filterForm.value.provider?.length ? '' : 'Provider' }}\n                                      </mat-label>\n                                  \n                                    <mat-select\n                                      formControlName=\"provider\"\n                                      multiple\n                                      panelClass=\"select-search-panel\"\n                                      (selectionChange)=\"applyFilters()\">\n                                  \n                                      <!-- Search box -->\n                                        <input style=\"border:1px solid #ccc; padding: 5px;width: 92%;margin: 5px;\"\n                                          matInput\n                                          placeholder=\"Search Provider\"\n                                          (click)=\"$event.stopPropagation()\"\n                                          (keydown)=\"$event.stopPropagation()\"\n                                          (keyup)=\"filterList($any($event.target).value, 'provider')\" />\n                                  \n                                      <!-- Values -->\n                                      <mat-option\n                                        *ngFor=\"let r of filteredProviders\"\n                                        [value]=\"r\">\n                                        {{ r }}\n                                      </mat-option>\n                                  \n                                    </mat-select>\n                                  </mat-form-field>\n                            </div>\n                        </div>\n                        <div style=\"margin-top: 45px;margin-left: 20px;\">\n                            <input class=\"btn-active\" type=\"button\" value=\"Reset All Filters\"\n                                (click)=\"resetFilters()\" />\n                        </div>\n                    </div>\n                    <div class=\"mt-4\">\n                        <div style=\"font-size:16px;font-weight:bold;color:#000\">\n                            Filtered Course Count : {{filterdCourses?.length}}\n                        </div>\n                    </div>\n                    <div class=\"mt-5 sub-heading select-all-container\" *ngIf=\"filterdCourses?.length\">\n                        <div style=\"margin-left: 16px;\">\n                            <mat-checkbox [checked]=\"false\" (change)=\"selectAllCourses($event)\">Select All\n                                Courses</mat-checkbox>\n                        </div>\n                        <div class=\"btn-group-compact\">\n                            <div>\n                                <input class=\"btn-active\" type=\"button\" value=\"Suggest More Course From iGOT\"\n                                    (click)=\"suggestMoreCourses()\" />\n                            </div>\n                            <div class=\"pl-2\">\n                                <input [disabled]=\"selectFilterCourses?.length > 0 ? false : true\"\n                                    [ngClass]=\"selectFilterCourses?.length > 0 ? 'btn-active' : 'btn-disable'\"\n                                    type=\"button\" [value]=\"mode === 'add' ? 'Save Courses' : 'Update Courses'\"\n                                    (click)=\"saveCourses()\" />\n                            </div>\n                        </div>\n                    </div>\n                    <div class=\"disclaimer-container mt-2\" *ngIf=\"filterdCourses?.length\">\n                        <div class=\"disclaimer-message mt-4\">\n                            <strong>Disclaimer:</strong> Please verify the public course URL before adding it to the plan.\n                        </div>\n                    </div>\n                    <div class=\"mt-2\">\n\n                        <div class=\"course-list-container\">\n                            <div\n                                [ngClass]=\"innerTabActiveIndex > 0 ? 'course-list-container-flex':'course-list-container-right-flex' \">\n                                <div *ngIf=\"innerTabActiveIndex > 0\"\n                                    [ngClass]=\"innerTabActiveIndex > 0 ? 'left-panel':''\">\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 1\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Behavioural</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                             class=\"category-list-item cursor-pointer mt-2\"\n                                             [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                             *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 2\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Functional</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                             class=\"category-list-item cursor-pointer mt-2\"\n                                             [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                             *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                    <ng-container *ngIf=\"innerTabActiveIndex === 3\">\n                                        <div class=\"sub-heading\">\n                                            <p>Competencies in Domain</p>\n                                        </div>\n                                        <div class=\"theme-filter-controls mb-2\" *ngIf=\"selectedThemeFilter\">\n                                            <button class=\"clear-filter-btn\" (click)=\"clearThemeFilter()\">\n                                                <mat-icon>clear</mat-icon> Clear Filter\n                                            </button>\n                                        </div>\n                                        <div (click)=\"filterOnCompetencyTheme(item)\"\n                                            class=\"category-list-item cursor-pointer mt-2\"\n                                            [ngClass]=\"{'selected-theme': isThemeSelected(item)}\"\n                                            *ngFor=\"let item of competencyMatchedByCategory\">\n                                            {{item}}\n                                        </div>\n                                    </ng-container>\n                                </div>\n                                <div [ngClass]=\"innerTabActiveIndex > 0 ? 'right-panel':'right-panel-flex'\">\n                                    <!-- No Course Found Message in Right Panel -->\n                                    <div class=\"no-course-found-container\"\n                                        *ngIf=\"filterdCourses?.length === 0 && selectedThemeFilter\">\n                                        <div class=\"no-course-card\">\n                                            <div class=\"no-course-icon\">\n                                                <mat-icon>search_off</mat-icon>\n                                            </div>\n                                            <div class=\"no-course-content\">\n                                                <h4>No Courses Found</h4>\n                                                <p>No courses found for the selected theme:\n                                                    <strong>{{selectedThemeFilter}}</strong></p>\n                                                <p>Would you like to add a course for this competency?</p>\n                                                <button class=\"suggest-course-btn\"\n                                                    (click)=\"addCourseForSelectedTheme()\">\n                                                    <mat-icon>add_circle</mat-icon>\n                                                    Add Course\n                                                </button>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <!-- Courses List -->\n                                    <div class=\"course-list-item\" *ngFor=\"let item of filterdCourses;let i=index\">\n\n                                        <div class=\"course-content\">\n                                            <div class=\"course-header\">\n                                                <div class=\"checked-course-container\">\n                                                    <div>\n                                                        <mat-checkbox [checked]=\"checkIfCourseExists(item)\"\n                                                            (change)=\"selectedFilterCourses($event, item)\"></mat-checkbox>\n                                                    </div>\n                                                    <div class=\"ml-2\">\n                                                        <div class=\"course-pill-container\">\n                                                            <div class=\"course-pill\">\n                                                                <div class=\"course-pill-text\">\n                                                                    <span><img\n                                                                            src=\"assets/icons/course.svg\"></span>&nbsp;<span>Course</span>\n                                                                </div>\n                                                            </div>\n                                                        </div>\n                                                    </div>\n\n                                                </div>\n\n                                                <!-- <div>\n                                        <div class=\"ai-recommened-pill\">\n                                            <div class=\"ai-recommened-pill-text\">\n                                                <span class=\"ai-loader-icon\"><img src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                <span *ngIf=\"item?.rationale\">AI Recommended\n                                                    <span *ngIf=\"item?.is_public\"> - Public</span>\n                                                    <span *ngIf=\"!item?.is_public\"> - iGOT</span>\n                                                </span>\n                                                <span *ngIf=\"!item?.rationale\">Manually Suggested - iGOT</span>\n\n                                            </div>\n                                        </div>\n                                    </div> -->\n                                                <div *ngIf=\"item?.rationale && !item?.is_public\">\n                                                    <div class=\"ai-recommened-pill-green\">\n                                                        <div class=\"ai-recommened-pill-green-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>AI Recommended - iGOT </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n                                                <div *ngIf=\"item?.rationale && item?.is_public\">\n                                                    <div class=\"ai-recommened-pill-public\">\n                                                        <div class=\"ai-recommened-pill-public-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>AI Recommended - Public </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n                                                <div *ngIf=\"!item?.rationale\">\n                                                    <div class=\"ai-recommened-pill-gray\">\n                                                        <div class=\"ai-recommened-pill-gray-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n\n                                                            <span>Manually Suggested - iGOT </span>\n\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.platform\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <a class=\"cursor-pointer\" [href]=\"item?.public_link\"\n                                                                target=\"_blank\"><span>Platform -\n                                                                    {{item?.platform}}</span></a>\n                                                        </div>\n                                                    </div>\n                                                    <div class=\"ai-recommened-pill-orange mt-2\" *ngIf=\"item?.organisation?.length\">\n                                                        <div class=\"ai-recommened-pill-orange-text\">\n                                                            <span class=\"ai-loader-icon\"><img\n                                                                    src=\"assets/icons/ai-loader.gif\"></span>\n                                                            <span>Provider - {{item?.organisation[0]}}</span>\n                                                        </div>\n                                                    </div>\n                                                </div>\n\n                                            </div>\n                                            <div class=\"course-title mt-3 cursor-pointer\" (click)=\"redirectToToc(item)\">\n                                                <span *ngIf=\"item?.course\">{{item?.course}}</span>\n                                                <!-- <span *ngIf=\"item?.name\">{{item?.name}}****</span> -->\n                                                <span style=\"margin-left:10px;\" (click)=\"redirectToToc(item)\"><img\n                                                        height=\"18px\" width=\"18px\"\n                                                        src=\"assets/icons/redirect.png\" /></span>\n                                            </div>\n                                            <div class=\"course-desc mt-2\">\n                                                <!-- <span *ngIf=\"item?.rationale\">{{item?.rationale}}</span> -->\n                                                <span *ngIf=\"item?.description\">{{item?.description}}</span>\n                                            </div>\n                                            <div class=\"mt-3\" *ngIf=\"getCompetenciesByType('Behavioural',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Behavioural Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"behavioural-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Behavioural',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Behavioural',i)\"\n                                                        class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Behavioural',i)\">\n                                                            {{ isExpanded('Behavioural',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Behavioural',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n                                            <div class=\"mt-2\" *ngIf=\"getCompetenciesByType('Functional',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Functional Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"functional-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Functional',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Functional',i)\"\n                                                        class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Functional',i)\">\n                                                            {{ isExpanded('Functional',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Functional',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n                                            <div class=\"mt-2\" *ngIf=\"getCompetenciesByType('Domain',i)?.length\">\n                                                <div class=\"competency-sub-heading\">Domain Competencies</div>\n                                                <ul class=\"competency-list mt-1\">\n                                                    <li class=\"domain-pill\"\n                                                        *ngFor=\"let comp of getDisplayedCompetencies('Domain',i)\">\n                                                        <span class=\"competency-text\"> {{ comp.competencyThemeName }} -\n                                                            {{\n                                                            comp.competencySubThemeName }} </span>\n                                                    </li>\n                                                    <li *ngIf=\"hasMoreThanTwo('Domain',i)\" class=\"show-more-competency\">\n                                                        <span class=\"show-more-link cursor-pointer\"\n                                                            (click)=\"toggleCompetencies('Domain',i)\">\n                                                            {{ isExpanded('Domain',i) ? 'Show Less' : '+' +\n                                                            getRemainingCount('Domain',i) + ' More' }}\n                                                        </span>\n                                                    </li>\n                                                </ul>\n                                            </div>\n\n\n                                        </div>\n\n                                        <!-- Relevancy and Duration section -->\n                                        <div class=\"course-footer\" *ngIf=\"item?.relevancy\">\n                                            <div class=\"relevancy-pill-green\">\n                                                <div class=\"relevancy-container\">\n                                                    <div class=\"relevancy\">Relevancy</div>\n                                                    <div class=\"dash\">-</div>\n                                                    <div class=\"percentage\">{{item?.relevancy}}%</div>\n                                                </div>\n                                            </div>\n                                            <div class=\"relevancy-pill-green\">\n                                                <div class=\"relevancy-container\">\n                                                    <div class=\"relevancy\">Duration</div>\n                                                    <div class=\"dash\">-</div>\n                                                    <div class=\"percentage\">\n                                                        <span\n                                                            *ngIf=\"item?.duration\">{{getDuration(item?.duration)}}</span>\n                                                        <span *ngIf=\"!(item?.duration)\">N/A</span>\n                                                    </div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                    </div>\n                                </div>\n                            </div>\n                        </div>\n                    </div>\n\n                    <!-- General No Data Message (only when no theme filter is active) -->\n                    <div class=\"mt-2 sub-heading\" *ngIf=\"filterdCourses?.length === 0 && !selectedThemeFilter\">\n                        <p>No Data Found</p>\n                    </div>\n                </div>\n            </div>\n        </form>\n            <div class=\"role-mapping-container\" *ngIf=\"outerTabActiveIndex === 1\">\n                <div id=\"gap-analysis-content\">\n\n                    <div class=\"download-pdf mt-4 mb-2\">\n                        <div>\n                            <input class=\"btn-active\" type=\"button\" value=\"Download\" (click)=\"downloadPDF()\" />\n                        </div>\n                    </div>\n                    <div>\n                        <!-- <div *ngIf=\"isPDFDownload\">\n                            <div class=\"pdf-heading\">{{sharedService?.cbpPlanFinalObj?.ministry?.name}} <span\n                                    *ngIf=\"planData?.designation_name \">_{{planData?.designation_name}}_Gap_Analysis</span>\n                            </div>\n                        </div> -->\n                        <div class=\"d-flex vh-100\" [ngClass]=\"isPDFDownload ? 'mt-4':''\">\n                            <!-- Sidebar -->\n                            <div class=\"d-flex flex-column p-3 bg-light border-end\" style=\"width: 250px;\">\n                                <h5 class=\"mb-4\">Analyze by Category</h5>\n                                <button *ngFor=\"let item of menuItems\"\n                                    class=\"btn btn-outline-primary mb-2 text-start menu-list-item\"\n                                    [class.active]=\"selectedCategory === item.key\" (click)=\"selectCategory(item.key)\">\n                                    {{ item.label }}\n                                </button>\n                            </div>\n\n                            <!-- Main Content -->\n                            <div class=\"flex-grow-1 p-4\">\n                                <div class=\"d-flex justify-content-between gap-3 \">\n                                    <div class=\"p-3 gray-bg\">\n                                        <div class=\"div-label sub-heading\">\n                                            <p>Competencies Covered</p>\n                                        </div>\n                                        <div class=\"div-count\">{{competencyCoveredCount}}</div>\n                                    </div>\n                                    <div class=\"p-3 gray-bg\">\n                                        <div class=\"div-label sub-heading\">\n                                            <p *ngIf=\"selectedCategory === 'all'\">Total Competencies</p>\n                                            <p *ngIf=\"selectedCategory === 'behavioral'\">Total Behavioural Competencies\n                                            </p>\n                                            <p *ngIf=\"selectedCategory === 'functional'\">Total Functional Competencies\n                                            </p>\n                                            <p *ngIf=\"selectedCategory === 'domain'\">Total Domain Competencies</p>\n                                        </div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'all'\">\n                                            {{this.planData?.competencies?.length}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            {{behavioralTotalCompetencies}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'functional'\">\n                                            {{functionalTotalCompetencies}}</div>\n                                        <div class=\"div-count\" *ngIf=\"selectedCategory === 'domain'\">\n                                            {{domainTotalCompetencies}}</div>\n                                    </div>\n                                    <div class=\"p-3 green-bg\">\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'all'\">Overall Coverage\n                                        </div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            Behavioural Coverage</div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'functional'\">\n                                            Functional Coverage</div>\n                                        <div class=\"div-green-label\" *ngIf=\"selectedCategory === 'domain'\">Domain\n                                            Coverage</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'all'\">\n                                            {{overallCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'behavioral'\">\n                                            {{behavioralCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'functional'\">\n                                            {{functionalCoverage}}</div>\n                                        <div class=\"div-green-count\" *ngIf=\"selectedCategory === 'domain'\">\n                                            {{domainCoverage}}</div>\n                                    </div>\n                                </div>\n                                <div class=\"mt-4 all-category-list\" [ngSwitch]=\"selectedCategory\">\n                                    <div *ngSwitchCase=\"'all'\">\n                                        <h4>All Categories</h4>\n\n                                        <!-- Show Behavioural section only if there are unmatched behavioural competencies -->\n                                        <div class=\"mt-4\"\n                                            *ngIf=\"behaviouralNotMatched && behaviouralNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Behavioural</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of behaviouralNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Behavioral')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show Functional section only if there are unmatched functional competencies -->\n                                        <div class=\"mt-4\"\n                                            *ngIf=\"functionalNotMatched && functionalNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Functional</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of functionalNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Functional')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show Domain section only if there are unmatched domain competencies -->\n                                        <div class=\"mt-4\" *ngIf=\"domainNotMatched && domainNotMatched.length > 0\">\n                                            <div class=\"sub-heading\">\n                                                <p>Domain</p>\n                                            </div>\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of domainNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item | titlecase}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Domain')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New\n                                                            Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n\n                                        <!-- Show message when all competencies are covered -->\n                                        <div class=\"mt-4 text-center\"\n                                            *ngIf=\"(!behaviouralNotMatched || behaviouralNotMatched.length === 0) && \n                                                                           (!functionalNotMatched || functionalNotMatched.length === 0) && \n                                                                           (!domainNotMatched || domainNotMatched.length === 0)\">\n                                            <div class=\"no-gaps-message\">\n                                                <mat-icon class=\"success-icon\">check_circle</mat-icon>\n                                                <h4>Excellent! All competencies are covered</h4>\n                                                <p>All required competencies have been addressed by the selected\n                                                    courses.</p>\n                                            </div>\n                                        </div>\n\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'behavioral'\">\n                                        <h4>Behavioural</h4>\n                                        <div class=\"mt-4\" *ngIf=\"behavioralCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Behavioural</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of behaviouralNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Behavioral')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course </span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"behavioralCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    🎉 Excellent! All behavioral competencies are covered by the\n                                                    selected courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'functional'\">\n                                        <h4>Functional</h4>\n                                        <div class=\"mt-4\" *ngIf=\"functionalCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Functional</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of functionalNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Functional')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course</span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"functionalCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    🎉 Excellent! All functional competencies are covered by the\n                                                    selected courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchCase=\"'domain'\">\n                                        <h4>Domain</h4>\n                                        <div class=\"mt-4\" *ngIf=\"domainCoverage !== '100%'\">\n                                            <!-- <div class=\"sub-heading\">\n                                            <p>Domain</p>\n                                        </div> -->\n                                            <div class=\"gray-bg-item\" *ngFor=\"let item of domainNotMatched\">\n                                                <div class=\"list-flex\">\n                                                    <div><span>{{item}}</span></div>\n                                                    <div class=\"cursor-pointer\" (click)=\"addCourse(item, 'Domain')\">\n                                                        <span class=\"add-btn\"><mat-icon>add</mat-icon> Add New Course </span></div>\n                                                </div>\n                                            </div>\n                                        </div>\n                                        <div class=\"mt-4\" *ngIf=\"domainCoverage === '100%'\">\n                                            <div class=\"p-3\"\n                                                style=\"background-color: #e8f5e8; border: 1px solid #4caf50; border-radius: 8px; text-align: center;\">\n                                                <div style=\"color: #2e7d32; font-weight: 600; font-size: 16px;\">\n                                                    🎉 Excellent! All domain competencies are covered by the selected\n                                                    courses.\n                                                </div>\n                                            </div>\n                                        </div>\n                                    </div>\n\n                                    <div *ngSwitchDefault>\n                                        <p>Please select a category.</p>\n                                    </div>\n                                </div>\n                            </div>\n                        </div>\n                    </div>\n                </div>\n\n            </div>\n        </div>\n        </div> <!-- Close main-content div -->\n\n    </div>\n</div>\n\n\n<div [hidden]=\"!isPDFDownload\" class=\"gap-analysis-pdf-container\" #pdfContent>\n    <div class=\"gap-analysis-pdf-header\">\n      <img src=\"assets/icons/karmayogiLogo-min.png\" alt=\"Karmayogi Bharat Logo\" class=\"logo\" />\n      <h1><span>\n        <span *ngIf=\"sharedService?.cbpPlanFinalObj?.ministry?.sbOrgType === 'state'\">{{sharedService?.cbpPlanFinalObj?.department_name?.name}}</span> \n        <span *ngIf=\"sharedService?.cbpPlanFinalObj?.ministry?.sbOrgType === 'ministry'\">{{sharedService?.cbpPlanFinalObj?.ministry?.name}}</span>   \n        <span *ngIf=\"planData?.designation_name \">/ {{planData?.designation_name}}</span>\n        </span></h1>\n      <p class=\"subtitle\">A detailed breakdown of competencies Gap Analysis</p>\n     \n    </div>\n  \n    <div class=\"competency-snapshot\">\n      <h2>Competency Snapshot</h2>\n      <div class=\"snapshot-content\">\n        <div class=\"circle-wrapper\">\n          <svg class=\"progress-ring\" width=\"120\" height=\"120\">\n            <circle class=\"progress-ring-bg\" cx=\"60\" cy=\"60\" r=\"52\" />\n            <circle class=\"progress-ring-circle\" cx=\"60\" cy=\"60\" r=\"52\" />\n          </svg>\n          <div class=\"percentage-text\">{{overallCoverage}}<br /><span>Overall Coverage</span></div>\n        </div>\n  \n        <div class=\"competency-container\">\n            <!-- Total Competencies Box -->\n            <div class=\"total-box\">\n              <div class=\"title\">Total Competencies</div>\n              <div class=\"count\">{{this.planData?.competencies?.length}}</div>\n            </div>\n          \n            <!-- Progress Bars -->\n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text behavioral\">Behavioural</span>\n                <span class=\"covered-text\">{{behavioralCompetencyCoveredCount}} / {{behavioralTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill behavioral\" [style.width.%]=\"(behavioralCompetencyCoveredCount / behavioralTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          \n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text functional\">Functional</span>\n                <span class=\"covered-text\">{{functionalCompetencyCoveredCount}} / {{functionalTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill functional\" [style.width.%]=\"(functionalCompetencyCoveredCount / functionalTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          \n            <div class=\"progress-group\">\n              <div class=\"progress-label\">\n                <span class=\"label-text domain\">Domain</span>\n                <span class=\"covered-text\">{{domainCompetencyCoveredCount}} / {{domainTotalCompetencies}} Covered</span>\n              </div>\n              <div class=\"progress-bar\">\n                <div class=\"progress-fill domain\" [style.width.%]=\"(domainCompetencyCoveredCount / domainTotalCompetencies) * 100\"></div>\n              </div>\n            </div>\n          </div>\n      </div>\n    </div>\n  \n    <div class=\"gap-section mb-4\">\n      <h2>Detailed Competency Analysis</h2>\n      <div class=\"gap-box\">\n        Bridge Your Competencies Gap\n        <p class=\"subtitle\">Here are {{this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)}} key areas for development.</p>\n    </div>\n    </div>\n    <div class=\"sub-heading mb-4\">\n        <p>Gap to Address <span *ngIf=\"(this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)) > 0\">({{this.planData?.competencies?.length - (behavioralCompetencyCoveredCount + functionalCompetencyCoveredCount + domainCompetencyCoveredCount)}})</span></p>\n        \n    </div>\n    <div class=\"competency-card behavioral\" *ngFor=\"let item of behaviouralNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n          &nbsp; • &nbsp;\n          <span class=\"tag behavioral\">Behavioural</span>\n        </div>\n    </div>\n      \n      <div class=\"competency-card functional\" *ngFor=\"let item of functionalNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n           &nbsp; • &nbsp;\n          <span class=\"tag functional\">Functional</span>\n        </div>\n      </div>\n      \n      <div class=\"competency-card domain\" *ngFor=\"let item of domainNotMatched\">\n        <div class=\"title\">{{item | titlecase}}</div>\n        <div class=\"subtitle\">\n          <!-- Project Management  -->\n          &nbsp; • &nbsp;\n          <span class=\"tag domain\">Domain</span>\n        </div>\n      </div>\n      <div class=\"sub-heading mb-4\">\n        <p>Covered Competencies <span>({{this.planData?.competencies?.length - (behaviouralNotMatched?.length + functionalNotMatched?.length + domainNotMatched?.length)}})</span></p>        \n     </div>\n     <div class=\"gap-section mb-4\">\n        \n        <div class=\"green-bg\">\n            <div class=\"div-green-label mb-2\">\n                Congratulations!\n            </div>            \n            <p>You have successfully covered </p>\n          <p class=\"subtitle\">{{this.planData?.competencies?.length - (behaviouralNotMatched?.length + functionalNotMatched?.length + domainNotMatched?.length)}} key competencies, forming a strong professional foundation.</p>\n      </div>\n      </div>\n      <div class=\"competency-card behavioral\" *ngFor=\"let item of behaviouralMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n          {{item?.sub_theme}}&nbsp; • &nbsp;\n          <span class=\"tag behavioral\">Behavioural</span>\n        </div>\n    </div>\n      \n      <div class=\"competency-card functional\" *ngFor=\"let item of functionalMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n            {{item?.sub_theme}}&nbsp; • &nbsp;\n          <span class=\"tag functional\">Functional</span>\n        </div>\n      </div>\n      \n      <div class=\"competency-card domain\" *ngFor=\"let item of domainMatched\">\n        <div class=\"title\">{{item?.theme | titlecase}}</div>\n        <div class=\"subtitle\">\n          <!-- Project Management  -->\n          {{item?.sub_theme}}&nbsp; • &nbsp;\n          <span class=\"tag domain\">Domain</span>\n        </div>\n      </div>\n      <div class=\"gap-section mb-4\">\n        <h2>Recommended Courses</h2>\n      </div>\n      <app-gap-analysis-recommended-course [planData]=\"planData\"></app-gap-analysis-recommended-course>\n</div>\n  \n\n\n<div class=\"overlay-loader\" *ngIf=\"loading && dataLoaded && !isRegeneratingWithProgress\">\n    <div class=\"loading-content\">\n        <mat-spinner diameter=\"50\"></mat-spinner>\n        <div class=\"loading-text mt-3\">\n            <p class=\"main-message\">{{ currentProcessingStage || 'Preparing course recommendation generation...' }}</p>\n            <div class=\"progress-details\">\n                <div class=\"progress-indicator\" *ngIf=\"progressPercentage > 0\">\n                    <div class=\"progress-bar-container\">\n                        <div class=\"progress-bar\" \n                             [style.width.%]=\"progressPercentage\">\n                        </div>\n                    </div>\n                    <small class=\"progress-text\">{{ progressPercentage }}% Complete</small>\n                </div>\n                <small class=\"time-estimate\">\n                    Real-time course generation in progress. This may take 1-2 minutes.\n                </small>\n            </div>\n        </div>\n    </div>\n</div>"]}