react-native-pdf-jsi 2.2.8 → 3.0.0

package/src/managers/AnalyticsManager.js

@@ -0,0 +1,695 @@
+/**
+ * AnalyticsManager - Reading Analytics and Insights
+ * Calculates reading statistics and generates personalized insights
+ * 
+ * LICENSE: Commercial License (Pro feature)
+ * 
+ * @author Punith M
+ * @version 1.0.0
+ */
+
+import bookmarkManager from '../bookmarks/BookmarkManager';
+import licenseManager from '../license/LicenseManager';
+
+/**
+ * AnalyticsManager Class
+ */
+export class AnalyticsManager {
+    constructor() {
+        this.initialized = false;
+    }
+
+    /**
+     * Initialize analytics
+     */
+    async initialize() {
+        // Check Pro license
+        licenseManager.requirePro('Reading Analytics');
+        
+        if (!this.initialized) {
+            await bookmarkManager.initialize();
+            this.initialized = true;
+        }
+    }
+
+    // ============================================
+    // CORE ANALYTICS
+    // ============================================
+
+    /**
+     * Get complete analytics for a PDF
+     * @param {string} pdfId - PDF identifier
+     * @returns {Promise<Object>} Complete analytics
+     */
+    async getAnalytics(pdfId) {
+        await this.initialize();
+
+        const progress = await bookmarkManager.getProgress(pdfId);
+        const bookmarks = await bookmarkManager.getBookmarks(pdfId);
+        const statistics = await bookmarkManager.getStatistics(pdfId);
+
+        return {
+            // Basic stats
+            ...statistics,
+            
+            // Reading metrics
+            readingMetrics: this.calculateReadingMetrics(progress),
+            
+            // Engagement metrics
+            engagementMetrics: this.calculateEngagement(progress, bookmarks),
+            
+            // Page analytics
+            pageAnalytics: this.analyzePages(progress, bookmarks),
+            
+            // Time analytics
+            timeAnalytics: this.analyzeTime(progress),
+            
+            // Predictions
+            predictions: this.generatePredictions(progress),
+            
+            // Insights
+            insights: this.generateInsights(progress, bookmarks, statistics),
+            
+            // Generated at
+            generatedAt: new Date().toISOString()
+        };
+    }
+
+    // ============================================
+    // READING METRICS
+    // ============================================
+
+    /**
+     * Calculate reading metrics
+     */
+    calculateReadingMetrics(progress) {
+        if (!progress || !progress.pagesRead || progress.pagesRead.length === 0) {
+            return this.getEmptyMetrics();
+        }
+
+        const { pagesRead, totalPages, timeSpent } = progress;
+
+        // Pages per hour
+        const hoursSpent = timeSpent / 3600;
+        const pagesPerHour = hoursSpent > 0 ? pagesRead.length / hoursSpent : 0;
+
+        // Minutes per page
+        const minutesPerPage = pagesRead.length > 0 ? (timeSpent / 60) / pagesRead.length : 0;
+
+        // Completion rate
+        const completionRate = totalPages > 0 ? (pagesRead.length / totalPages) * 100 : 0;
+
+        // Reading speed (words per minute estimate)
+        // Assuming ~250 words per page average
+        const estimatedWords = pagesRead.length * 250;
+        const minutesSpent = timeSpent / 60;
+        const wordsPerMinute = minutesSpent > 0 ? estimatedWords / minutesSpent : 0;
+
+        return {
+            pagesPerHour: Math.round(pagesPerHour * 10) / 10,
+            minutesPerPage: Math.round(minutesPerPage * 10) / 10,
+            completionRate: Math.round(completionRate),
+            wordsPerMinute: Math.round(wordsPerMinute),
+            totalPagesRead: pagesRead.length,
+            totalPages,
+            timeSpent: Math.round(timeSpent),
+            estimatedTotalTime: this.estimateTotalTime(progress),
+            estimatedTimeRemaining: this.estimateTimeRemaining(progress)
+        };
+    }
+
+    /**
+     * Calculate engagement metrics
+     */
+    calculateEngagement(progress, bookmarks) {
+        const bookmarkRate = progress.totalPages > 0 
+            ? (bookmarks.length / progress.totalPages) * 100 
+            : 0;
+
+        const uniqueBookmarkPages = new Set(bookmarks.map(b => b.page)).size;
+        
+        return {
+            totalBookmarks: bookmarks.length,
+            uniqueBookmarkedPages: uniqueBookmarkPages,
+            bookmarkRate: Math.round(bookmarkRate * 10) / 10,
+            averageBookmarksPerPage: bookmarks.length > 0 
+                ? Math.round((bookmarks.length / uniqueBookmarkPages) * 10) / 10 
+                : 0,
+            engagementScore: this.calculateEngagementScore(progress, bookmarks)
+        };
+    }
+
+    /**
+     * Calculate engagement score (0-100)
+     */
+    calculateEngagementScore(progress, bookmarks) {
+        let score = 0;
+
+        // Completion contributes 40 points
+        score += (progress.percentage || 0) * 0.4;
+
+        // Bookmarks contribute 30 points
+        const bookmarkScore = Math.min((bookmarks.length / progress.totalPages) * 100, 30);
+        score += bookmarkScore;
+
+        // Session frequency contributes 30 points
+        const sessionScore = Math.min((progress.sessions || 0) * 3, 30);
+        score += sessionScore;
+
+        return Math.min(Math.round(score), 100);
+    }
+
+    // ============================================
+    // PAGE ANALYTICS
+    // ============================================
+
+    /**
+     * Analyze page patterns
+     */
+    analyzePages(progress, bookmarks) {
+        const { pagesRead, totalPages } = progress;
+
+        // Create page heatmap
+        const heatmap = {};
+        bookmarks.forEach(b => {
+            heatmap[b.page] = (heatmap[b.page] || 0) + 1;
+        });
+
+        // Find most bookmarked pages
+        const sortedPages = Object.entries(heatmap)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([page, count]) => ({ page: parseInt(page), bookmarks: count }));
+
+        // Identify reading gaps
+        const gaps = this.findReadingGaps(pagesRead, totalPages);
+
+        // Reading pattern
+        const pattern = this.identifyReadingPattern(pagesRead);
+
+        return {
+            mostBookmarkedPages: sortedPages,
+            readingGaps: gaps,
+            readingPattern: pattern,
+            heatmap
+        };
+    }
+
+    /**
+     * Find gaps in reading (unread sections)
+     */
+    findReadingGaps(pagesRead, totalPages) {
+        if (!pagesRead || pagesRead.length === 0) return [];
+
+        const gaps = [];
+        const sortedPages = [...pagesRead].sort((a, b) => a - b);
+
+        for (let i = 0; i < sortedPages.length - 1; i++) {
+            const current = sortedPages[i];
+            const next = sortedPages[i + 1];
+            
+            if (next - current > 1) {
+                gaps.push({
+                    start: current + 1,
+                    end: next - 1,
+                    size: next - current - 1
+                });
+            }
+        }
+
+        return gaps.slice(0, 5); // Top 5 gaps
+    }
+
+    /**
+     * Identify reading pattern (linear, random, skip)
+     */
+    identifyReadingPattern(pagesRead) {
+        if (!pagesRead || pagesRead.length < 3) {
+            return 'insufficient_data';
+        }
+
+        const sortedPages = [...pagesRead].sort((a, b) => a - b);
+        let sequentialCount = 0;
+        let skipCount = 0;
+
+        for (let i = 0; i < sortedPages.length - 1; i++) {
+            const diff = sortedPages[i + 1] - sortedPages[i];
+            if (diff === 1) {
+                sequentialCount++;
+            } else if (diff > 5) {
+                skipCount++;
+            }
+        }
+
+        const sequentialRate = sequentialCount / (sortedPages.length - 1);
+        const skipRate = skipCount / (sortedPages.length - 1);
+
+        if (sequentialRate > 0.7) return 'linear'; // Reading sequentially
+        if (skipRate > 0.5) return 'selective'; // Jumping around
+        return 'mixed'; // Mix of both
+    }
+
+    // ============================================
+    // TIME ANALYTICS
+    // ============================================
+
+    /**
+     * Analyze time patterns
+     */
+    analyzeTime(progress) {
+        const { timeSpent, sessions, pagesRead } = progress;
+
+        if (!timeSpent || !sessions) {
+            return {
+                averageSessionTime: 0,
+                totalTime: 0,
+                efficiency: 0
+            };
+        }
+
+        const averageSessionTime = timeSpent / sessions;
+        const minutesSpent = timeSpent / 60;
+        const hoursSpent = timeSpent / 3600;
+
+        // Efficiency: pages per minute
+        const efficiency = pagesRead.length > 0 ? pagesRead.length / minutesSpent : 0;
+
+        return {
+            totalTimeSeconds: timeSpent,
+            totalTimeMinutes: Math.round(minutesSpent),
+            totalTimeHours: Math.round(hoursSpent * 10) / 10,
+            totalSessions: sessions,
+            averageSessionTime: Math.round(averageSessionTime),
+            averageSessionMinutes: Math.round(averageSessionTime / 60),
+            efficiency: Math.round(efficiency * 100) / 100,
+            formattedTotalTime: this.formatDuration(timeSpent),
+            formattedAverageSession: this.formatDuration(averageSessionTime)
+        };
+    }
+
+    /**
+     * Estimate total reading time
+     */
+    estimateTotalTime(progress) {
+        const { pagesRead, totalPages, timeSpent } = progress;
+
+        if (!pagesRead || pagesRead.length === 0 || !timeSpent) {
+            return null;
+        }
+
+        const avgTimePerPage = timeSpent / pagesRead.length;
+        const estimatedTotal = avgTimePerPage * totalPages;
+
+        return {
+            seconds: Math.round(estimatedTotal),
+            minutes: Math.round(estimatedTotal / 60),
+            hours: Math.round((estimatedTotal / 3600) * 10) / 10,
+            formatted: this.formatDuration(estimatedTotal)
+        };
+    }
+
+    /**
+     * Estimate time remaining
+     */
+    estimateTimeRemaining(progress) {
+        const { pagesRead, totalPages, timeSpent } = progress;
+
+        if (!pagesRead || pagesRead.length === 0 || !timeSpent) {
+            return null;
+        }
+
+        const avgTimePerPage = timeSpent / pagesRead.length;
+        const pagesRemaining = totalPages - pagesRead.length;
+        const timeRemaining = avgTimePerPage * pagesRemaining;
+
+        return {
+            seconds: Math.round(timeRemaining),
+            minutes: Math.round(timeRemaining / 60),
+            hours: Math.round((timeRemaining / 3600) * 10) / 10,
+            formatted: this.formatDuration(timeRemaining)
+        };
+    }
+
+    // ============================================
+    // PREDICTIONS & INSIGHTS
+    // ============================================
+
+    /**
+     * Generate predictions
+     */
+    generatePredictions(progress) {
+        const { pagesRead, totalPages, timeSpent, sessions } = progress;
+
+        if (!pagesRead || pagesRead.length < 5) {
+            return {
+                completionDate: null,
+                remainingSessions: null,
+                message: 'Read at least 5 pages for predictions'
+            };
+        }
+
+        // Calculate average progress per session
+        const pagesPerSession = pagesRead.length / sessions;
+
+        // Estimate sessions needed
+        const pagesRemaining = totalPages - pagesRead.length;
+        const sessionsRemaining = Math.ceil(pagesRemaining / pagesPerSession);
+
+        // Estimate completion date (assuming 1 session per day)
+        const completionDate = new Date();
+        completionDate.setDate(completionDate.getDate() + sessionsRemaining);
+
+        return {
+            sessionsRemaining: Math.round(sessionsRemaining),
+            completionDate: completionDate.toISOString(),
+            completionDateFormatted: completionDate.toLocaleDateString(),
+            pagesPerSession: Math.round(pagesPerSession * 10) / 10,
+            estimatedDaysToComplete: sessionsRemaining
+        };
+    }
+
+    /**
+     * Generate personalized insights
+     */
+    generateInsights(progress, bookmarks, statistics) {
+        const insights = [];
+
+        // Reading speed insight
+        const minutesPerPage = statistics.avgTimePerPage / 60;
+        if (minutesPerPage > 0) {
+            if (minutesPerPage < 2) {
+                insights.push({
+                    type: 'speed',
+                    icon: '⚡',
+                    title: 'Fast Reader',
+                    message: `You're reading at ${Math.round(minutesPerPage * 10) / 10} minutes per page - that's fast!`,
+                    sentiment: 'positive'
+                });
+            } else if (minutesPerPage > 5) {
+                insights.push({
+                    type: 'speed',
+                    icon: '🐢',
+                    title: 'Thorough Reader',
+                    message: `You take your time (${Math.round(minutesPerPage)} min/page). Quality over speed!`,
+                    sentiment: 'neutral'
+                });
+            }
+        }
+
+        // Progress insight
+        if (progress.percentage >= 75) {
+            insights.push({
+                type: 'progress',
+                icon: '🎯',
+                title: 'Almost There!',
+                message: `You've completed ${progress.percentage}% - keep going!`,
+                sentiment: 'positive'
+            });
+        } else if (progress.percentage < 25 && progress.sessions > 3) {
+            insights.push({
+                type: 'progress',
+                icon: '💪',
+                title: 'Keep Reading',
+                message: `You've started strong with ${progress.sessions} sessions. Keep the momentum!`,
+                sentiment: 'encouraging'
+            });
+        }
+
+        // Bookmark insight
+        const bookmarkRate = statistics.pagesRead > 0 
+            ? (bookmarks.length / statistics.pagesRead) * 100 
+            : 0;
+
+        if (bookmarkRate > 20) {
+            insights.push({
+                type: 'engagement',
+                icon: '📚',
+                title: 'Active Reader',
+                message: `You've bookmarked ${bookmarks.length} pages - you're highly engaged!`,
+                sentiment: 'positive'
+            });
+        }
+
+        // Session consistency
+        if (progress.sessions >= 5) {
+            const avgPagesPerSession = progress.pagesRead.length / progress.sessions;
+            insights.push({
+                type: 'consistency',
+                icon: '📊',
+                title: 'Consistent Reader',
+                message: `You average ${Math.round(avgPagesPerSession)} pages per session across ${progress.sessions} sessions.`,
+                sentiment: 'neutral'
+            });
+        }
+
+        // Reading gaps
+        const gaps = this.findReadingGaps(progress.pagesRead, progress.totalPages);
+        if (gaps.length > 0 && gaps[0].size > 10) {
+            insights.push({
+                type: 'gaps',
+                icon: '📖',
+                title: 'Reading Gap Detected',
+                message: `You skipped pages ${gaps[0].start}-${gaps[0].end}. Want to go back?`,
+                sentiment: 'suggestion',
+                action: {
+                    type: 'navigate',
+                    page: gaps[0].start
+                }
+            });
+        }
+
+        // Time remaining
+        const estimate = this.estimateTimeRemaining(progress);
+        if (estimate && estimate.hours > 0) {
+            insights.push({
+                type: 'prediction',
+                icon: '⏱️',
+                title: 'Time to Finish',
+                message: `About ${estimate.formatted} of reading time remaining.`,
+                sentiment: 'informative'
+            });
+        }
+
+        return insights;
+    }
+
+    // ============================================
+    // STATISTICS CALCULATIONS
+    // ============================================
+
+    /**
+     * Calculate reading streak
+     * @param {string} pdfId - PDF identifier
+     * @returns {Promise<Object>} Streak information
+     */
+    async getReadingStreak(pdfId) {
+        // This would require session timestamps
+        // For now, return basic info
+        const progress = await bookmarkManager.getProgress(pdfId);
+
+        return {
+            currentStreak: progress.sessions || 0,
+            longestStreak: progress.sessions || 0,
+            lastReadDate: progress.lastRead
+        };
+    }
+
+    /**
+     * Get reading history
+     * @param {string} pdfId - PDF identifier
+     * @returns {Promise<Array>} Reading history
+     */
+    async getReadingHistory(pdfId) {
+        const progress = await bookmarkManager.getProgress(pdfId);
+
+        // Create basic history from available data
+        return {
+            sessions: progress.sessions || 0,
+            firstSession: progress.createdAt,
+            lastSession: progress.lastRead,
+            totalTime: progress.timeSpent || 0,
+            pagesRead: progress.pagesRead || []
+        };
+    }
+
+    /**
+     * Compare with average reader
+     */
+    getComparison(progress) {
+        const { pagesRead, timeSpent, sessions } = progress;
+
+        // Industry averages (approximate)
+        const avgPagesPerHour = 30; // Average reader
+        const avgMinutesPerPage = 2;
+        const avgSessionsPerWeek = 5;
+
+        // User's stats
+        const hoursSpent = timeSpent / 3600;
+        const userPagesPerHour = hoursSpent > 0 ? pagesRead.length / hoursSpent : 0;
+        const userMinutesPerPage = pagesRead.length > 0 ? (timeSpent / 60) / pagesRead.length : 0;
+
+        return {
+            speedComparison: {
+                user: Math.round(userPagesPerHour),
+                average: avgPagesPerHour,
+                percentile: this.calculatePercentile(userPagesPerHour, avgPagesPerHour)
+            },
+            thoroughness: {
+                user: Math.round(userMinutesPerPage * 10) / 10,
+                average: avgMinutesPerPage,
+                message: userMinutesPerPage > avgMinutesPerPage 
+                    ? 'You read more thoroughly than average'
+                    : 'You read faster than average'
+            },
+            engagement: {
+                user: sessions,
+                message: sessions > 5 
+                    ? 'You\'re a dedicated reader!'
+                    : 'Keep building your reading habit'
+            }
+        };
+    }
+
+    /**
+     * Calculate percentile
+     */
+    calculatePercentile(userValue, avgValue) {
+        const ratio = userValue / avgValue;
+        
+        if (ratio >= 1.5) return 90; // Top 10%
+        if (ratio >= 1.2) return 75; // Top 25%
+        if (ratio >= 0.8) return 50; // Average
+        if (ratio >= 0.5) return 25; // Below average
+        return 10; // Bottom 10%
+    }
+
+    // ============================================
+    // RECOMMENDATIONS
+    // ============================================
+
+    /**
+     * Generate reading recommendations
+     */
+    generateRecommendations(progress, bookmarks) {
+        const recommendations = [];
+
+        // Recommend filling gaps
+        const gaps = this.findReadingGaps(progress.pagesRead, progress.totalPages);
+        if (gaps.length > 0) {
+            recommendations.push({
+                type: 'gap',
+                priority: 'high',
+                title: 'Fill Reading Gaps',
+                message: `You have ${gaps.length} gaps in your reading. Review pages ${gaps[0].start}-${gaps[0].end}?`,
+                action: {
+                    type: 'navigate',
+                    page: gaps[0].start
+                }
+            });
+        }
+
+        // Recommend review of bookmarked pages
+        if (bookmarks.length > 5 && progress.percentage > 50) {
+            recommendations.push({
+                type: 'review',
+                priority: 'medium',
+                title: 'Review Bookmarks',
+                message: `You have ${bookmarks.length} bookmarks. Consider reviewing important sections.`,
+                action: {
+                    type: 'show_bookmarks'
+                }
+            });
+        }
+
+        // Recommend completion
+        if (progress.percentage >= 80 && progress.percentage < 100) {
+            const remaining = progress.totalPages - progress.pagesRead.length;
+            recommendations.push({
+                type: 'completion',
+                priority: 'high',
+                title: 'Finish Reading',
+                message: `Only ${remaining} pages left! You can finish this.`,
+                action: {
+                    type: 'navigate',
+                    page: progress.currentPage
+                }
+            });
+        }
+
+        return recommendations;
+    }
+
+    // ============================================
+    // UTILITY METHODS
+    // ============================================
+
+    /**
+     * Format duration in human-readable form
+     */
+    formatDuration(seconds) {
+        if (!seconds || seconds < 60) {
+            return `${Math.round(seconds)}s`;
+        }
+
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) {
+            return `${minutes}m`;
+        }
+
+        const hours = Math.floor(minutes / 60);
+        const remainingMinutes = minutes % 60;
+        
+        if (hours < 24) {
+            return remainingMinutes > 0 
+                ? `${hours}h ${remainingMinutes}m`
+                : `${hours}h`;
+        }
+
+        const days = Math.floor(hours / 24);
+        const remainingHours = hours % 24;
+        
+        return remainingHours > 0 
+            ? `${days}d ${remainingHours}h`
+            : `${days}d`;
+    }
+
+    /**
+     * Get empty metrics (when no data)
+     */
+    getEmptyMetrics() {
+        return {
+            pagesPerHour: 0,
+            minutesPerPage: 0,
+            completionRate: 0,
+            wordsPerMinute: 0,
+            totalPagesRead: 0,
+            totalPages: 0,
+            timeSpent: 0,
+            estimatedTotalTime: null,
+            estimatedTimeRemaining: null
+        };
+    }
+
+    /**
+     * Export analytics data
+     * @param {string} pdfId - PDF identifier
+     * @returns {Promise<Object>} Export data
+     */
+    async exportAnalytics(pdfId) {
+        const analytics = await this.getAnalytics(pdfId);
+
+        return {
+            pdfId,
+            analytics,
+            exportedAt: new Date().toISOString(),
+            format: 'json',
+            version: '1.0.0'
+        };
+    }
+}
+
+// Create singleton instance
+const analyticsManager = new AnalyticsManager();
+
+export default analyticsManager;
+