/**
 * SCCE/HCCA Custom GTM Event Tracker
 * Uses the existing fontevaGTM library to track various user interactions
 * and leverages native GTM events when possible
 */
(function() {
    // Make sure GTMLibrary is available
    if (typeof GTMLibrary === 'undefined' || !GTMLibrary.DataLayerHelper) {
        console.warn('GTMLibrary not found, custom event tracking disabled');
        return;
    }

    // Get reference to the DataLayerHelper
    const DataLayerHelper = GTMLibrary.DataLayerHelper;

    /**
     * SCCE/HCCA Custom Event Tracker
     * Handles tracking of various user interactions specific to SCCE/HCCA
     */
    class SCCEEventTracker {
        constructor(options = {}) {
            // Configuration options
            this.debug = options.debug || this.isDebugMode();
            this.trackingEnabled = options.trackingEnabled !== false;
            
            // URL patterns for different types of links
            this.membershipUrlPattern = /my\.corporatecompliance\.org\/s\/form\?id=/i;
            this.resourceExtensions = ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.zip'];
            this.certificationUrlPattern = /certifications\//i;
            
            // Track initialization timestamp
            this.initTime = new Date();
            
            // Initialize the tracker
            this.init();
            
            if (this.debug) {
                console.log('%c SCCE Tracker Initialized', 'background: #2c3e50; color: white; padding: 5px; border-radius: 3px;', {
                    time: this.initTime,
                    debug: this.debug,
                    trackingEnabled: this.trackingEnabled,
                    dataLayerAvailable: !!window.dataLayer,
                    GTMLibraryAvailable: !!GTMLibrary
                });
            }
        }
        
        /**
         * Determine if we're in debug mode based on URL param or localStorage
         */
        isDebugMode() {
            try {
                // Check URL parameter
                const urlParams = new URLSearchParams(window.location.search);
                if (urlParams.has('scce_debug')) return true;
                
                // Check localStorage setting
                if (localStorage.getItem('scce_debug') === 'true') return true;
                
                // Check for development environments
                const hostname = window.location.hostname;
                if (hostname.includes('localhost') || 
                    hostname.includes('dev.') || 
                    hostname.includes('staging.') ||
                    hostname.includes('test.')) {
                    return true;
                }
                
                return false;
            } catch (e) {
                // If any errors occur, default to false
                return false;
            }
        }

        /**
         * Initialize tracking by setting up event listeners
         */
        init() {
            if (!this.trackingEnabled) {
                if (this.debug) console.log('SCCE Tracker: Tracking disabled, skipping initialization');
                return;
            }
            
            try {
                // Perform diagnostics
                this.performDiagnostics();
                
                // Set up listeners
                this.setupGTMEventListeners();
                
                // Set up a backup mechanism for direct observation of membership links
                // This will only activate if we detect that GTM events aren't being processed
                this.setupDirectLinkObservation();

                // Set up specific event listeners for membership, resource, and certification links
                this.setupRemoveFromCartTracking();
                
                if (this.debug) {
                    // Add a global debug method
                    window.SCCETrackerDebug = () => this.debugReport();
                    console.log('SCCE Tracker: Debug method available via window.SCCETrackerDebug()');
                }
            } catch (error) {
                console.error('SCCE Tracker: Initialization error', error);
            }
        }
        
        /**
         * Collect and report diagnostic information
         */
        performDiagnostics() {
            if (!this.debug) return;
            
            try {
                const diagnostics = {
                    browser: navigator.userAgent,
                    url: window.location.href,
                    dataLayer: !!window.dataLayer,
                    dataLayerType: typeof window.dataLayer,
                    dataLayerLength: window.dataLayer ? window.dataLayer.length : 0,
                    GTMLibraryAvailable: !!GTMLibrary,
                    DataLayerHelperAvailable: !!(GTMLibrary && GTMLibrary.DataLayerHelper),
                    timestamp: new Date().toISOString()
                };
                
                // Check for GTM container
                const hasGTMScript = !!document.querySelector('script[src*="googletagmanager"]');
                diagnostics.hasGTMScript = hasGTMScript;
                
                // Check if GTM is loaded correctly
                if (window.google_tag_manager) {
                    diagnostics.googleTagManagerLoaded = true;
                    diagnostics.gtmContainerIds = Object.keys(window.google_tag_manager)
                        .filter(key => key.startsWith('GTM-'));
                } else {
                    diagnostics.googleTagManagerLoaded = false;
                }
                
                console.log('%c SCCE Tracker Diagnostics', 'background: #34495e; color: white; padding: 3px; border-radius: 3px;', diagnostics);
                
                // Look for membership links on the page
                const potentialMembershipLinks = [...document.querySelectorAll('a[href*="form?id="]')];
                if (potentialMembershipLinks.length > 0) {
                    console.log('SCCE Tracker: Found potential membership links:', potentialMembershipLinks);
                }
            } catch (e) {
                console.error('SCCE Tracker: Error during diagnostics', e);
            }
        }
        
        /**
         * Generate a complete debug report
         */
        debugReport() {
            const report = {
                timestamp: new Date().toISOString(),
                trackerVersion: '1.3.0', // Updated with enhanced price extraction
                initialized: !!this.initTime,
                initTime: this.initTime,
                config: {
                    debug: this.debug,
                    trackingEnabled: this.trackingEnabled
                },
                browser: navigator.userAgent,
                url: window.location.href,
                dataLayer: {
                    available: !!window.dataLayer,
                    type: typeof window.dataLayer,
                    length: window.dataLayer ? window.dataLayer.length : 0
                },
                gtm: {
                    libraryAvailable: !!GTMLibrary,
                    helperAvailable: !!(GTMLibrary && GTMLibrary.DataLayerHelper),
                    hasGTMScript: !!document.querySelector('script[src*="googletagmanager"]'),
                    googleTagManagerLoaded: !!window.google_tag_manager
                }
            };
            
            console.table(report);
            return report;
        }
        
        /**
         * Set up direct observation of membership links as a backup
         */
        setupDirectLinkObservation() {
            // This is a fallback in case GTM events aren't capturing properly
            try {
                setTimeout(() => {
                    // Only set this up if we detected membership links and need additional tracking
                    const membershipLinks = [...document.querySelectorAll('a[href*="form?id="]')];
                    if (membershipLinks.length > 0) {
                        if (this.debug) {
                            console.log('SCCE Tracker: Setting up direct link observation for', membershipLinks.length, 'membership links');
                        }
                        
                        membershipLinks.forEach(link => {
                            // Check if this link already has our listener
                            if (!link.dataset.scceTracked) {
                                link.dataset.scceTracked = 'true';
                                link.addEventListener('click', (e) => {
                                    if (this.debug) console.log('SCCE Tracker: Direct membership link click detected', link.href);
                                    
                                    // Try to get organization and tier from text content
                                    let organization = 'Unknown';
                                    let tier = 'Unknown';
                                    
                                    const linkText = link.textContent.trim();
                                    if (linkText.includes('SCCE')) organization = 'SCCE';
                                    else if (linkText.includes('HCCA')) organization = 'HCCA';
                                    
                                    if (linkText.includes('Student')) tier = 'Student';
                                    else if (linkText.includes('Individual')) tier = 'Individual';
                                    else if (linkText.includes('Group')) tier = 'Group';
                                    
                                    // Push a direct event that we know will work
                                    try {
                                        window.dataLayer.push({
                                            event: 'membership_join_click_backup',
                                            membership: {
                                                organization: organization,
                                                tier: tier,
                                                url: link.href,
                                                text: linkText,
                                                method: 'direct_observation',
                                                timestamp: new Date().toISOString()
                                            }
                                        });
                                    } catch (e) {
                                        console.error('SCCE Tracker: Direct observation event failed', e);
                                    }
                                });
                            }
                        });
                    }
                }, 2000); // Wait 2 seconds to ensure page is fully loaded
            } catch (e) {
                console.error('SCCE Tracker: Error setting up direct observation', e);
            }
        }

        /**
         * Set up listeners for GTM events
         */
        setupGTMEventListeners() {
            // Listen for GTM link click events which are already being fired
            if (window.dataLayer) {
                try {
                    // Store the original dataLayer.push function
                    const originalPush = window.dataLayer.push;
                    
                    // Override the push function to intercept GTM events
                    window.dataLayer.push = (...args) => {
                        try {
                            // Call the original function
                            const result = originalPush.apply(window.dataLayer, args);
                            
                            // Process each argument (usually just one object)
                            args.forEach(data => {
                                if (data && data.event === 'gtm.linkClick') {
                                    // Wrap in a try/catch to ensure GTM events aren't interrupted
                                    try {
                                        this.handleLinkClickEvent(data);
                                    } catch (innerError) {
                                        if (this.debug) {
                                            console.error('SCCE Tracker: Error in link click handler:', innerError);
                                        }
                                    }
                                }
                            });
                            
                            return result;
                        } catch (error) {
                            // Make sure we always call the original function
                            if (this.debug) {
                                console.error('SCCE Tracker: Error in dataLayer intercept:', error);
                            }
                            return originalPush.apply(window.dataLayer, args);
                        }
                    };
                    
                    if (this.debug) {
                        console.log('%c SCCE Tracker: GTM event listener active', 'background: #2980b9; color: white; padding: 3px;');
                    }
                    
                    // Also check for any previously fired events
                    this.checkHistoricalEvents();
                    
                } catch (setupError) {
                    console.error('SCCE Tracker: Failed to set up GTM event listener:', setupError);
                }
            } else if (this.debug) {
                console.warn('SCCE Tracker: dataLayer not found, cannot intercept GTM events');
            }
        }
        
        /**
         * Check for previously fired GTM events in the dataLayer
         */
        checkHistoricalEvents() {
            try {
                if (window.dataLayer && Array.isArray(window.dataLayer)) {
                    if (this.debug) {
                        console.log(`SCCE Tracker: Checking ${window.dataLayer.length} historical dataLayer events`);
                    }
                    
                    let linkClicksFound = 0;
                    
                    // Process existing events in the dataLayer
                    window.dataLayer.forEach(data => {
                        if (data && data.event === 'gtm.linkClick') {
                            linkClicksFound++;
                            try {
                                this.handleLinkClickEvent(data);
                            } catch (e) {
                                // Don't let errors in one event stop processing
                                if (this.debug) {
                                    console.error('SCCE Tracker: Error processing historical event:', e);
                                }
                            }
                        }
                    });
                    
                    if (this.debug && linkClicksFound > 0) {
                        console.log(`SCCE Tracker: Processed ${linkClicksFound} historical link click events`);
                    }
                }
            } catch (error) {
                console.error('SCCE Tracker: Error checking historical events:', error);
            }
        }

        /**
         * Handle click on a membership join link
         */
        handleMembershipLinkClick(element) {
            // Get the membership information from the closest heading
            const heading = this.getClosestHeading(element);
            const membershipType = heading ? heading.textContent.trim() : 'Unknown Membership';
            const linkText = element.textContent.trim();
            const linkUrl = element.href;
            
            // Extract the organization (SCCE or HCCA) from the membership type
            const organization = membershipType.includes('SCCE') ? 'SCCE' : 
                                membershipType.includes('HCCA') ? 'HCCA' : 'Unknown';
            
            // Extract membership tier (Individual, Group, Student)
            const tier = this.getMembershipTier(membershipType);
            
            // Track the event
            this.trackMembershipStart(organization, tier, linkUrl);
            
            // Store the membership type for later use
            try {
                localStorage.setItem('membership_type', `${organization} ${tier}`);
            } catch (e) {
                // Silently fail if localStorage is not available
            }
        }

        /**
         * Handle click on a resource link (downloads, etc)
         */
        handleResourceLinkClick(element) {
            try {
                const linkText = element.textContent.trim();
                const linkUrl = element.href;
                const resourceType = this.getResourceType(element);
                
                // Track the resource click event
                DataLayerHelper.push('resource_click', {
                    resource: {
                        name: linkText,
                        url: linkUrl,
                        type: resourceType
                    }
                });
            } catch (error) {
                console.error('Failed to track resource click', error);
            }
        }

        /**
         * Handle click on a certification link
         */
        handleCertificationLinkClick(element) {
            try {
                const linkText = element.textContent.trim();
                const linkUrl = element.href;
                const certificationName = this.getClosestHeading(element)?.textContent.trim() || linkText;
                
                // Track the certification click event
                DataLayerHelper.push('certification_click', {
                    certification: {
                        name: certificationName,
                        link_text: linkText,
                        url: linkUrl
                    }
                });
            } catch (error) {
                console.error('Failed to track certification click', error);
            }
        }

        /**
         * Find the closest heading element to the clicked link
         */
        getClosestHeading(element) {
            let current = element;
            while (current && current.tagName !== 'BODY') {
                // Look for a preceding heading
                let sibling = current.previousElementSibling;
                while (sibling) {
                    if (sibling.tagName === 'H4' || sibling.tagName === 'H3' || sibling.tagName === 'H2') {
                        return sibling;
                    }
                    sibling = sibling.previousElementSibling;
                }
                
                current = current.parentElement;
            }
            return null;
        }

        /**
         * Extract membership tier from the heading text
         */
        getMembershipTier(headingText) {
            if (headingText.includes('Student')) return 'Student';
            if (headingText.includes('Individual or Group')) {
                // For individual/group links, extract from the price description or link text
                const parentDiv = document.querySelector(`h4:contains('${headingText}')`).closest('div');
                if (parentDiv) {
                    const descText = parentDiv.querySelector('.item_desc').textContent;
                    // Check if the click is closer to the individual or group pricing text
                    if (descText.indexOf('Group') > descText.indexOf('Individual')) {
                        return 'Group';
                    }
                }
                return 'Individual'; // Default to Individual if we can't determine
            }
            return 'Unknown';
        }

        /**
         * Determine the type of resource being accessed
         */
        getResourceType(element) {
            const url = element.href.toLowerCase();
            const linkText = element.textContent.trim().toLowerCase();
            
            if (url.endsWith('.pdf')) return 'PDF';
            if (url.endsWith('.doc') || url.endsWith('.docx')) return 'Word Document';
            if (url.endsWith('.xls') || url.endsWith('.xlsx')) return 'Excel Spreadsheet';
            if (url.endsWith('.ppt') || url.endsWith('.pptx')) return 'PowerPoint';
            if (url.endsWith('.zip')) return 'ZIP Archive';
            
            if (linkText.includes('whitepaper')) return 'Whitepaper';
            if (linkText.includes('guide')) return 'Guide';
            if (linkText.includes('report')) return 'Report';
            if (linkText.includes('webinar')) return 'Webinar';
            
            return 'Other';
        }

        /**
         * Track membership join start
         */
        async trackMembershipStart(organization, tier, linkUrl) {
            console.group('%c SCCE Tracker: Membership Tracking', 'background: #8e44ad; color: white; padding: 3px; border-radius: 3px;');
            try {
                console.log('Membership details:', { organization, tier, linkUrl });
                
                const membershipType = `${organization} ${tier}`;
                let formId = 'unknown';
                let pageTitle = document.title || 'Unknown Page';
                let pagePath = window.location.pathname || '/unknown';
                
                try {
                    // Handle URL parsing safely with additional error details
                    console.log('Parsing URL:', linkUrl);
                    const urlObj = new URL(linkUrl);
                    formId = urlObj.searchParams.get('id') || 'unknown';
                    console.log('Form ID extracted:', formId);
                    
                    // Get additional URL parameters that might be useful
                    const urlParams = {};
                    urlObj.searchParams.forEach((value, key) => {
                        urlParams[key] = value;
                    });
                    console.log('All URL parameters:', urlParams);
                    
                } catch (urlError) {
                    console.warn('Failed to parse URL:', urlError.message);
                    
                    // Try a simpler way to get form ID if URL parsing failed
                    const idMatch = linkUrl.match(/[?&]id=([^&]*)/);
                    if (idMatch && idMatch[1]) {
                        formId = idMatch[1];
                        console.log('Form ID extracted via regex:', formId);
                    }
                }
                
                // Log debug information before proceeding
                console.log('About to push membership event with:', {
                    event: 'membership_join_click',
                    step: 0,
                    membershipType,
                    stepTitle: 'Join Process Started',
                    additionalData: {
                        form_id: formId,
                        link_url: linkUrl,
                        page_title: pageTitle,
                        page_path: pagePath,
                        timestamp: new Date().toISOString()
                    }
                });
                
                // Check if DataLayerHelper is available before trying to use it
                if (!DataLayerHelper || typeof DataLayerHelper.pushMembershipEvent !== 'function') {
                    throw new Error('DataLayerHelper.pushMembershipEvent is not available');
                }
                
                // Use the existing membership_start event with step 0 to indicate the join process is starting
                await DataLayerHelper.pushMembershipEvent(
                    'membership_join_click', // event name
                    0, // step (0 means start)
                    membershipType, // membership type
                    'Join Process Started', // step title
                    { // additional data
                        form_id: formId,
                        link_url: linkUrl,
                        page_title: pageTitle,
                        page_path: pagePath,
                        timestamp: new Date().toISOString()
                    }
                );
                console.log('%c Event pushed successfully! ✅', 'color: green; font-weight: bold;');
                
            } catch (error) {
                console.error('%c Error tracking membership join click:', 'color: red; font-weight: bold;', error);
                
                // Additional error diagnostics
                console.log('Error stack:', error.stack);
                console.log('DataLayerHelper available:', !!DataLayerHelper);
                console.log('window.dataLayer available:', !!window.dataLayer);
                
                // Try direct dataLayer push as fallback
                try {
                    console.log('Attempting fallback event push...');
                    if (window.dataLayer) {
                        const fallbackEvent = {
                            event: 'membership_join_click_fallback',
                            membership: {
                                organization: organization,
                                tier: tier,
                                url: linkUrl,
                                error: error.message,
                                timestamp: new Date().toISOString()
                            }
                        };
                        
                        window.dataLayer.push(fallbackEvent);
                        console.log('%c Fallback event pushed successfully! ✅', 'color: orange; font-weight: bold;', fallbackEvent);
                    }
                } catch (e) {
                    console.error('%c Even fallback failed:', 'color: red; font-weight: bold;', e);
                    
                    // Super simple last-resort tracking
                    try {
                        const img = new Image();
                        const params = encodeURIComponent(JSON.stringify({
                            org: organization,
                            tier: tier,
                            timestamp: new Date().toISOString(),
                            error: "Main and fallback tracking failed"
                        }));
                        img.src = `https://www.corporatecompliance.org/tracking-pixel.gif?data=${params}`;
                    } catch (imgError) {
                        // Nothing more we can do
                    }
                }
            } finally {
                console.groupEnd();
            }
        }

        /**
         * Handle link click events from GTM
         */
        handleLinkClickEvent(data) {
            try {
                // Add detailed logging with distinctive styling for easier debugging
                console.log('%c SCCE Tracker: Link Click Event Detected', 'background: #e67e22; color: white; padding: 3px; border-radius: 3px;', data);
                
                // Check if we have the needed data
                if (!data || !data.gtm || !data.gtm.elementUrl) {
                    console.warn('%c SCCE Tracker: Missing required GTM data', 'background: #c0392b; color: white; padding: 3px;', data);
                    return;
                }
                
                const linkUrl = data.gtm.elementUrl;
                const linkText = data.gtm.elementText || '';
                const element = data.gtm.element;
                
                // Log what we found with structured data
                console.log('%c SCCE Tracker: Link Details', 'background: #3498db; color: white; padding: 3px;', {
                    url: linkUrl,
                    text: linkText,
                    element: element,
                    isMembership: this.membershipUrlPattern.test(linkUrl),
                    isResource: this.isResourceLink(linkUrl),
                    isCertification: this.certificationUrlPattern.test(linkUrl)
                });
                
                // Process membership links
                if (this.membershipUrlPattern.test(linkUrl)) {
                    console.log('%c SCCE Tracker: Processing Membership Link', 'background: #2ecc71; color: white; padding: 3px;');
                    
                    // For membership links, find nearby headings to determine membership type
                    let organization = 'Unknown';
                    let tier = 'Unknown';
                    
                    // Try to extract organization from URL or text
                    if (linkText.includes('SCCE')) {
                        organization = 'SCCE';
                    } else if (linkText.includes('HCCA')) {
                        organization = 'HCCA';
                    }
                    
                    // Try to extract tier from URL or text
                    if (linkText.includes('Student')) {
                        tier = 'Student';
                    } else if (linkText.includes('Group')) {
                        tier = 'Group';
                    } else if (linkText.includes('Individual')) {
                        tier = 'Individual';
                    } else {
                        tier = 'Standard'; // Default
                    }
                    
                    // Try to get from DOM if possible
                    if (element && typeof element !== 'string') {
                        console.log('SCCE Tracker: Examining DOM element for heading context');
                        const heading = this.getClosestHeading(element);
                        if (heading) {
                            const headingText = heading.textContent.trim();
                            console.log('SCCE Tracker: Found heading:', headingText);
                            
                            if (headingText.includes('SCCE')) organization = 'SCCE';
                            else if (headingText.includes('HCCA')) organization = 'HCCA';
                            
                            if (headingText.includes('Student')) tier = 'Student';
                            else tier = this.getMembershipTier(headingText);
                        } else {
                            console.log('SCCE Tracker: No related heading found');
                        }
                    }
                    
                    console.log('%c SCCE Tracker: Membership Details', 'background: #9b59b6; color: white; padding: 3px;', {
                        organization,
                        tier,
                        linkUrl,
                        linkText
                    });
                    
                    // Add a direct dataLayer push first as a guaranteed event
                    try {
                        window.dataLayer.push({
                            event: 'membership_join_click_direct',
                            membership: {
                                organization: organization,
                                tier: tier,
                                url: linkUrl,
                                text: linkText,
                                timestamp: new Date().toISOString()
                            }
                        });
                        console.log('SCCE Tracker: Direct membership event pushed to dataLayer');
                    } catch (directError) {
                        console.error('SCCE Tracker: Direct event push failed', directError);
                    }
                    
                    // Also track using the more complex method
                    this.trackMembershipStart(organization, tier, linkUrl);
                    return;
                }
                
                // Process resource links
                if (this.isResourceLink(linkUrl)) {
                    console.log('%c SCCE Tracker: Processing Resource Link', 'background: #f39c12; color: white; padding: 3px;');
                    const resourceType = this.getResourceTypeFromUrl(linkUrl);
                    DataLayerHelper.push('resource_click', {
                        resource: {
                            name: linkText,
                            url: linkUrl,
                            type: resourceType,
                            timestamp: new Date().toISOString()
                        }
                    });
                    return;
                }
                
                // Process certification links
                if (this.certificationUrlPattern.test(linkUrl)) {
                    console.log('%c SCCE Tracker: Processing Certification Link', 'background: #16a085; color: white; padding: 3px;');
                    DataLayerHelper.push('certification_click', {
                        certification: {
                            name: linkText,
                            url: linkUrl,
                            timestamp: new Date().toISOString()
                        }
                    });
                    return;
                }
                
                console.log('SCCE Tracker: No special tracking for this link');
                
            } catch (error) {
                console.error('%c SCCE Custom Tracker: Error processing link click', 'background: #e74c3c; color: white; padding: 3px;', error);
                // If we get an error, try a super simple tracking approach as last resort
                try {
                    if (window.dataLayer && data && data.gtm && data.gtm.elementUrl) {
                        window.dataLayer.push({
                            event: 'scce_tracker_error_fallback',
                            error: error.message,
                            link_url: data.gtm.elementUrl,
                            timestamp: new Date().toISOString()
                        });
                    }
                } catch (e) {
                    // At this point we can't do anything more
                }
            }
        }
        
        /**
         * Check if a URL is for a resource (PDF, Doc, etc.)
         */
        isResourceLink(url) {
            if (!url) return false;
            url = url.toLowerCase();
            
            // Check if URL ends with any of the resource extensions
            return this.resourceExtensions.some(ext => url.endsWith(ext)) || 
                  url.includes('/resources/') || 
                  url.includes('/downloads/');
        }
        
        /**
         * Get resource type from URL
         */
        getResourceTypeFromUrl(url) {
            if (!url) return 'Other';
            url = url.toLowerCase();
            
            if (url.endsWith('.pdf')) return 'PDF';
            if (url.endsWith('.doc') || url.endsWith('.docx')) return 'Word Document';
            if (url.endsWith('.xls') || url.endsWith('.xlsx')) return 'Excel Spreadsheet';
            if (url.endsWith('.ppt') || url.endsWith('.pptx')) return 'PowerPoint';
            if (url.endsWith('.zip')) return 'ZIP Archive';
            
            if (url.includes('whitepaper')) return 'Whitepaper';
            if (url.includes('guide')) return 'Guide';
            if (url.includes('report')) return 'Report';
            if (url.includes('webinar')) return 'Webinar';
            
            return 'Other';
        }

        /**
         * Public method to track a custom event
         * This can be used by other scripts to track custom events
         */
        trackCustomEvent(eventName, eventData) {
            try {
                DataLayerHelper.push(eventName, eventData);
            } catch (error) {
                console.error(`Failed to track custom event: ${eventName}`, error);
            }
        }

        /**
         * Enhanced price extraction with multiple fallback strategies
         * Matches the logic from fontevaGTMmin.js to capture actual charged amounts
         */
        extractPrice(element) {
            if (!element) return 0;
            
            // Strategy 1: Try multiple specific selectors in priority order
            const priceSelectors = [
                '[data-name="parentPrice"] .FrameworkCurrencyField',
                '[data-name="itemPrice"] .FrameworkCurrencyField', 
                '.pfm-text-body_small[data-name="itemPrice"] span',
                '[data-name="itemPrice"] .currencyInputSpan',
                '.FrameworkCurrencyField'
            ];
            
            for (const selector of priceSelectors) {
                const priceEl = element.querySelector(selector);
                if (priceEl && priceEl.textContent) {
                    const priceText = priceEl.textContent.trim();
                    if (priceText.match(/(\$|USD)?\s*\d+(\.\d+)?/)) {
                        const price = parseFloat(priceText.replace(/[^\d.]/g, ''));
                        if (price > 0) {
                            if (this.debug) {
                                console.log(`SCCE Tracker: Price extracted via ${selector}: $${price}`);
                            }
                            return price;
                        }
                    }
                }
            }
            
            // Strategy 2: Fallback - search all elements for price patterns
            if (this.debug) {
                console.log('SCCE Tracker: Primary selectors failed, using fallback strategy');
            }
            
            const allElements = element.querySelectorAll('*');
            for (const el of allElements) {
                if (el.textContent) {
                    const text = el.textContent.trim();
                    const priceMatch = text.match(/(\$|USD)?\s*(\d+(\.\d+)?)/);
                    if (priceMatch && !text.includes('Quantity')) {
                        const price = parseFloat(priceMatch[2]);
                        if (price > 0) {
                            if (this.debug) {
                                console.log(`SCCE Tracker: Price extracted via fallback: $${price} from "${text}"`);
                            }
                            return price;
                        }
                    }
                }
            }
            
            if (this.debug) {
                console.warn('SCCE Tracker: No valid price found, returning 0');
            }
            return 0;
        }

        /**
         * Set up tracking for "Remove from Cart" actions
         */
        setupRemoveFromCartTracking() {
            document.body.addEventListener('click', (e) => {
                const removeBtn = e.target.closest('button[data-name="remove-from-additional-cart"]');
                if (!removeBtn) return;

                const cartItem = removeBtn.closest('.pfm-cart_item-detail');
                if (!cartItem) return;

                try {
                    const nameEl = cartItem.querySelector('[data-name="subscriptionPlanName"]');
                    const quantityEl = cartItem.querySelector('[data-name="parentQuantity"]');

                    const name = nameEl?.textContent?.trim() || 'Unknown Item';
                    const quantity = parseInt(quantityEl?.textContent?.replace('Quantity:', '').trim() || '1', 10);
                    
                    // Use enhanced price extraction
                    const price = this.extractPrice(cartItem);

                    const item = {
                        id: cartItem.getAttribute('data-id') || name.replace(/\s+/g, '_').toLowerCase(),
                        name,
                        quantity,
                        price
                    };

                    if (this.debug) {
                        console.log('%c SCCE Tracker: remove_from_cart item', 'background: #c0392b; color: white; padding: 3px;', item);
                    }

                    if (GTMLibrary?.ProductTracker?.trackRemoveFromCart) {
                        GTMLibrary.ProductTracker.trackRemoveFromCart(item);
                    } else {
                        console.warn('SCCE Tracker: GTMLibrary.ProductTracker.trackRemoveFromCart not available');
                    }
                } catch (err) {
                    console.error('SCCE Tracker: Failed to track remove_from_cart event', err);
                }
            });
        }


    }

    // Create a global instance for external access with safe initialization
    let trackerInitialized = false;
    try {
        window.SCCETracker = new SCCEEventTracker({
            debug: window.location.hostname.includes('localhost') || 
                  window.location.search.includes('scce_debug')
        });
        trackerInitialized = true;
    } catch (e) {
        console.error('Failed to initialize SCCE Tracker:', e);
    }

    // Expose public methods for external use with safety checks
    window.trackSCCEEvent = function(eventName, eventData) {
        try {
            if (window.SCCETracker) {
                window.SCCETracker.trackCustomEvent(eventName, eventData);
                return true;
            }
            return false;
        } catch (error) {
            console.error('Error in trackSCCEEvent:', error);
            return false;
        }
    };
    
    // Add a script loaded indicator in the DOM
    try {
        const scriptLoadedMarker = document.createElement('meta');
        scriptLoadedMarker.setAttribute('name', 'scce-tracker-loaded');
        scriptLoadedMarker.setAttribute('content', trackerInitialized ? 'true' : 'false');
        document.head.appendChild(scriptLoadedMarker);
    } catch (e) {
        // Silently fail
    }
    
    // Expose version and status information
    window.SCCETrackerInfo = {
        version: '1.3.0',
        initialized: trackerInitialized,
        loadTime: new Date().toISOString()
    };
    
    // Log successful initialization
    if (trackerInitialized) {
        console.log('%c SCCE Custom Tracker Loaded ✅', 'background: #27ae60; color: white; padding: 5px; border-radius: 3px;');
    }

})();