// Analytics Implementation Verification Script
console.log('=== Analytics Implementation Verification ===');

// Check if the main HTML file contains the analytics button
function checkAnalyticsButton() {
    console.log('\n1. Checking Analytics Button Implementation:');
    
    try {
        const fs = require('fs');
        const htmlContent = fs.readFileSync('index.html', 'utf8');
        
        const hasAnalyticsBtn = htmlContent.includes('id="analyticsBtn"');
        const hasCorrectClasses = htmlContent.includes('btn btn-info') && htmlContent.includes('analyticsBtn');
        const hasAriaLabel = htmlContent.includes('aria-label="View detailed analytics dashboard"');
        
        console.log(`   ✓ Analytics button in HTML: ${hasAnalyticsBtn ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Correct button classes: ${hasCorrectClasses ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Accessibility label: ${hasAriaLabel ? 'FOUND' : 'MISSING'}`);
        
        return hasAnalyticsBtn && hasCorrectClasses && hasAriaLabel;
    } catch (error) {
        console.log(`   ✗ Error checking HTML: ${error.message}`);
        return false;
    }
}

// Check if the analytics modal is properly implemented
function checkAnalyticsModal() {
    console.log('\n2. Checking Analytics Modal Implementation:');
    
    try {
        const fs = require('fs');
        const htmlContent = fs.readFileSync('index.html', 'utf8');
        
        const hasAnalyticsModal = htmlContent.includes('id="analyticsModal"');
        const hasModalContent = htmlContent.includes('analytics-modal-content');
        const hasTabs = htmlContent.includes('analytics-tabs');
        const hasTabContents = htmlContent.includes('analytics-tab-content');
        
        // Check for all 4 tabs
        const hasOverviewTab = htmlContent.includes('data-tab="overview"');
        const hasTrendsTab = htmlContent.includes('data-tab="trends"');
        const hasHealthTab = htmlContent.includes('data-tab="health"');
        const hasUsageTab = htmlContent.includes('data-tab="usage"');
        
        // Check for key elements
        const hasSummaryCards = htmlContent.includes('summary-cards');
        const hasChartContainers = htmlContent.includes('chart-container');
        const hasCanvasElements = htmlContent.includes('<canvas id="statusChart"');
        
        console.log(`   ✓ Analytics modal: ${hasAnalyticsModal ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Modal content structure: ${hasModalContent ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Tab navigation: ${hasTabs ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Tab contents: ${hasTabContents ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Overview tab: ${hasOverviewTab ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Trends tab: ${hasTrendsTab ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Health tab: ${hasHealthTab ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Usage tab: ${hasUsageTab ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Summary cards: ${hasSummaryCards ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Chart containers: ${hasChartContainers ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Canvas elements: ${hasCanvasElements ? 'FOUND' : 'MISSING'}`);
        
        return hasAnalyticsModal && hasModalContent && hasTabs && hasTabContents && 
               hasOverviewTab && hasTrendsTab && hasHealthTab && hasUsageTab;
    } catch (error) {
        console.log(`   ✗ Error checking modal: ${error.message}`);
        return false;
    }
}

// Check if the CSS styles are properly implemented
function checkAnalyticsStyles() {
    console.log('\n3. Checking Analytics CSS Styles:');
    
    try {
        const fs = require('fs');
        const cssContent = fs.readFileSync('styles.css', 'utf8');
        
        const hasAnalyticsModalStyles = cssContent.includes('.analytics-modal-content');
        const hasTabStyles = cssContent.includes('.analytics-tab');
        const hasSummaryCardStyles = cssContent.includes('.summary-card');
        const hasChartStyles = cssContent.includes('.chart-container');
        const hasHealthStyles = cssContent.includes('.health-summary');
        const hasUsageStyles = cssContent.includes('.usage-stats');
        const hasResponsiveStyles = cssContent.includes('@media (max-width: 768px)') && 
                                   cssContent.includes('.analytics-modal-content');
        
        console.log(`   ✓ Analytics modal styles: ${hasAnalyticsModalStyles ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Tab styles: ${hasTabStyles ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Summary card styles: ${hasSummaryCardStyles ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Chart container styles: ${hasChartStyles ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Health report styles: ${hasHealthStyles ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Usage pattern styles: ${hasUsageStyles ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Responsive styles: ${hasResponsiveStyles ? 'FOUND' : 'MISSING'}`);
        
        return hasAnalyticsModalStyles && hasTabStyles && hasSummaryCardStyles && 
               hasChartStyles && hasHealthStyles && hasUsageStyles;
    } catch (error) {
        console.log(`   ✗ Error checking CSS: ${error.message}`);
        return false;
    }
}

// Check if the JavaScript functionality is properly implemented
function checkAnalyticsJavaScript() {
    console.log('\n4. Checking Analytics JavaScript Implementation:');
    
    try {
        const fs = require('fs');
        const jsContent = fs.readFileSync('script.js', 'utf8');
        
        // Check for main analytics methods
        const hasShowAnalyticsModal = jsContent.includes('showAnalyticsModal()');
        const hasInitializeAnalytics = jsContent.includes('initializeAnalytics()');
        const hasBindAnalyticsTabEvents = jsContent.includes('bindAnalyticsTabEvents()');
        const hasLoadTabAnalytics = jsContent.includes('loadTabAnalytics(');
        
        // Check for tab-specific methods
        const hasLoadOverviewAnalytics = jsContent.includes('loadOverviewAnalytics()');
        const hasLoadTrendsAnalytics = jsContent.includes('loadTrendsAnalytics()');
        const hasLoadHealthAnalytics = jsContent.includes('loadHealthAnalytics()');
        const hasLoadUsageAnalytics = jsContent.includes('loadUsageAnalytics()');
        
        // Check for chart creation methods
        const hasCreateStatusChart = jsContent.includes('createStatusChart()');
        const hasCreateFoldersChart = jsContent.includes('createFoldersChart()');
        const hasCreateTrendsChart = jsContent.includes('createTrendsChart(');
        const hasCreateTestingTrendsChart = jsContent.includes('createTestingTrendsChart(');
        
        // Check for health and usage methods
        const hasCalculateHealthMetrics = jsContent.includes('calculateHealthMetrics()');
        const hasCalculateUsageMetrics = jsContent.includes('calculateUsageMetrics()');
        
        // Check for chart drawing utilities
        const hasDrawPieChart = jsContent.includes('drawPieChart(');
        const hasDrawBarChart = jsContent.includes('drawBarChart(');
        const hasDrawLineChart = jsContent.includes('drawLineChart(');
        const hasDrawMultiLineChart = jsContent.includes('drawMultiLineChart(');
        
        // Check for export functionality
        const hasExportAnalyticsData = jsContent.includes('exportAnalyticsData()');
        const hasGenerateAnalyticsReport = jsContent.includes('generateAnalyticsReport()');
        
        // Check for event bindings
        const hasAnalyticsButtonEvent = jsContent.includes('analyticsBtn') && jsContent.includes('addEventListener');
        const hasExportButtonEvents = jsContent.includes('exportAnalyticsBtn') && jsContent.includes('generateReportBtn');
        
        console.log(`   ✓ showAnalyticsModal method: ${hasShowAnalyticsModal ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ initializeAnalytics method: ${hasInitializeAnalytics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ bindAnalyticsTabEvents method: ${hasBindAnalyticsTabEvents ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ loadTabAnalytics method: ${hasLoadTabAnalytics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ loadOverviewAnalytics method: ${hasLoadOverviewAnalytics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ loadTrendsAnalytics method: ${hasLoadTrendsAnalytics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ loadHealthAnalytics method: ${hasLoadHealthAnalytics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ loadUsageAnalytics method: ${hasLoadUsageAnalytics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ createStatusChart method: ${hasCreateStatusChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ createFoldersChart method: ${hasCreateFoldersChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ createTrendsChart method: ${hasCreateTrendsChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ createTestingTrendsChart method: ${hasCreateTestingTrendsChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ calculateHealthMetrics method: ${hasCalculateHealthMetrics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ calculateUsageMetrics method: ${hasCalculateUsageMetrics ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ drawPieChart method: ${hasDrawPieChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ drawBarChart method: ${hasDrawBarChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ drawLineChart method: ${hasDrawLineChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ drawMultiLineChart method: ${hasDrawMultiLineChart ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ exportAnalyticsData method: ${hasExportAnalyticsData ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ generateAnalyticsReport method: ${hasGenerateAnalyticsReport ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Analytics button event binding: ${hasAnalyticsButtonEvent ? 'FOUND' : 'MISSING'}`);
        console.log(`   ✓ Export button event bindings: ${hasExportButtonEvents ? 'FOUND' : 'MISSING'}`);
        
        return hasShowAnalyticsModal && hasInitializeAnalytics && hasBindAnalyticsTabEvents &&
               hasLoadOverviewAnalytics && hasLoadTrendsAnalytics && hasLoadHealthAnalytics &&
               hasLoadUsageAnalytics && hasCalculateHealthMetrics && hasCalculateUsageMetrics &&
               hasExportAnalyticsData && hasGenerateAnalyticsReport;
    } catch (error) {
        console.log(`   ✗ Error checking JavaScript: ${error.message}`);
        return false;
    }
}

// Check for requirements compliance
function checkRequirementsCompliance() {
    console.log('\n5. Checking Requirements Compliance:');
    
    try {
        const fs = require('fs');
        const htmlContent = fs.readFileSync('index.html', 'utf8');
        const jsContent = fs.readFileSync('script.js', 'utf8');
        
        // Requirement 9.1, 9.2: Detailed analytics dashboard showing bookmark usage patterns
        const hasAnalyticsDashboard = htmlContent.includes('Analytics Dashboard') && 
                                     jsContent.includes('showAnalyticsModal');
        
        // Requirement 9.3, 9.4: Charts and graphs for bookmark statistics over time
        const hasChartsAndGraphs = htmlContent.includes('<canvas') && 
                                  jsContent.includes('drawPieChart') && 
                                  jsContent.includes('drawBarChart') && 
                                  jsContent.includes('drawLineChart');
        
        // Requirement 9.5: Bookmark health reports (broken links, old bookmarks)
        const hasHealthReports = htmlContent.includes('Health Report') && 
                                jsContent.includes('calculateHealthMetrics') &&
                                jsContent.includes('displayHealthIssues');
        
        // Requirement 9.6: Export functionality for statistics data
        const hasExportFunctionality = htmlContent.includes('exportAnalyticsBtn') && 
                                      htmlContent.includes('generateReportBtn') &&
                                      jsContent.includes('exportAnalyticsData') &&
                                      jsContent.includes('generateAnalyticsReport');
        
        console.log(`   ✓ Detailed analytics dashboard (9.1, 9.2): ${hasAnalyticsDashboard ? 'IMPLEMENTED' : 'MISSING'}`);
        console.log(`   ✓ Charts and graphs over time (9.3, 9.4): ${hasChartsAndGraphs ? 'IMPLEMENTED' : 'MISSING'}`);
        console.log(`   ✓ Bookmark health reports (9.5): ${hasHealthReports ? 'IMPLEMENTED' : 'MISSING'}`);
        console.log(`   ✓ Export functionality (9.6): ${hasExportFunctionality ? 'IMPLEMENTED' : 'MISSING'}`);
        
        return hasAnalyticsDashboard && hasChartsAndGraphs && hasHealthReports && hasExportFunctionality;
    } catch (error) {
        console.log(`   ✗ Error checking requirements: ${error.message}`);
        return false;
    }
}

// Run all checks
function runAllChecks() {
    console.log('Starting Analytics Implementation Verification...\n');
    
    const buttonCheck = checkAnalyticsButton();
    const modalCheck = checkAnalyticsModal();
    const stylesCheck = checkAnalyticsStyles();
    const jsCheck = checkAnalyticsJavaScript();
    const requirementsCheck = checkRequirementsCompliance();
    
    console.log('\n=== VERIFICATION SUMMARY ===');
    console.log(`Analytics Button Implementation: ${buttonCheck ? 'PASS' : 'FAIL'}`);
    console.log(`Analytics Modal Implementation: ${modalCheck ? 'PASS' : 'FAIL'}`);
    console.log(`Analytics CSS Styles: ${stylesCheck ? 'PASS' : 'FAIL'}`);
    console.log(`Analytics JavaScript: ${jsCheck ? 'PASS' : 'FAIL'}`);
    console.log(`Requirements Compliance: ${requirementsCheck ? 'PASS' : 'FAIL'}`);
    
    const overallPass = buttonCheck && modalCheck && stylesCheck && jsCheck && requirementsCheck;
    console.log(`\nOVERALL RESULT: ${overallPass ? 'PASS ✓' : 'FAIL ✗'}`);
    
    if (overallPass) {
        console.log('\n🎉 Analytics implementation is complete and meets all requirements!');
        console.log('\nFeatures implemented:');
        console.log('• Detailed analytics dashboard with 4 tabs (Overview, Trends, Health, Usage)');
        console.log('• Interactive charts and graphs showing bookmark statistics over time');
        console.log('• Comprehensive health reports identifying broken links and old bookmarks');
        console.log('• Export functionality for analytics data (JSON) and reports (Markdown)');
        console.log('• Responsive design for mobile and desktop');
        console.log('• Accessibility features with proper ARIA labels');
    } else {
        console.log('\n❌ Some issues were found. Please review the failed checks above.');
    }
    
    return overallPass;
}

// Export for use in Node.js or run directly
if (typeof module !== 'undefined' && module.exports) {
    module.exports = {
        checkAnalyticsButton,
        checkAnalyticsModal,
        checkAnalyticsStyles,
        checkAnalyticsJavaScript,
        checkRequirementsCompliance,
        runAllChecks
    };
} else {
    // Run checks if executed directly
    runAllChecks();
}