background.js

// Background service worker for the Breathe extension

class BreathingBackground {
    constructor() {
        this.setupEventListeners();
        this.initializeNotifications();
    }
    
    setupEventListeners() {
        // Handle extension installation
        chrome.runtime.onInstalled.addListener((details) => {
            if (details.reason === 'install') {
                this.handleFirstInstall();
            }
        });
        
        // Handle alarm events for session reminders
        chrome.alarms.onAlarm.addListener((alarm) => {
            this.handleAlarm(alarm);
        });
        
        // Handle messages from popup
        chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
            this.handleMessage(message, sender, sendResponse);
            return true; // Indicates async response
        });
    }
    
    async handleFirstInstall() {
    // Initialize default settings
    const defaultSettings = {
        breathingPattern: '478',
        sessionDuration: 1,
        soundEnabled: true,
        sessions: [],
        todaySessions: [],
        reminderEnabled: false,
        reminderInterval: 60 // minutes
    };

    // This part was missing!
    await chrome.storage.local.set(defaultSettings);

    // Show welcome notification after a short delay
    setTimeout(() => {
        this.showNotification(
            'Welcome to Breathe!',
            'Start your first breathing session to reduce stress and improve focus.',
            'icons/icon48.png'
        );
    }, 1000);
}
    
    async handleAlarm(alarm) {
        switch (alarm.name) {
            case 'breathingReminder':
                await this.showBreathingReminder();
                break;
            case 'sessionComplete':
                await this.handleSessionComplete();
                break;
        }
    }
    
    async handleMessage(message, sender, sendResponse) {
        switch (message.action) {
            case 'startSession':
                await this.startSessionTracking(message.data);
                sendResponse({ success: true });
                break;
                
            case 'completeSession':
                await this.completeSessionTracking(message.data);
                sendResponse({ success: true });
                break;
                
            case 'setReminder':
                await this.setBreathingReminder(message.interval);
                sendResponse({ success: true });
                break;
                
            case 'clearReminder':
                await this.clearBreathingReminder();
                sendResponse({ success: true });
                break;
        }
    }
    
    async startSessionTracking(sessionData) {
        // Set alarm for session completion
        chrome.alarms.create('sessionComplete', {
            delayInMinutes: sessionData.duration
        });
        
        // Store session start time
        await chrome.storage.local.set({
            currentSession: {
                ...sessionData,
                startTime: Date.now()
            }
        });
    }
    
    async completeSessionTracking(sessionData) {
        // Clear any pending session alarms
        chrome.alarms.clear('sessionComplete');
        
        // Update session statistics
        const result = await chrome.storage.local.get(['sessions', 'todaySessions', 'weeklyGoal']);
        const sessions = result.sessions || [];
        const todaySessions = result.todaySessions || [];
        
        const today = new Date().toISOString().split('T')[0];
        const completedSession = {
            ...sessionData,
            date: today,
            completedAt: Date.now()
        };
        
        sessions.push(completedSession);
        todaySessions.push(completedSession);
        
        await chrome.storage.local.set({
            sessions,
            todaySessions,
            currentSession: null
        });
        
        // Check for achievements
        await this.checkAchievements(sessions, todaySessions);
    }
    
    async checkAchievements(allSessions, todaySessions) {
        const today = new Date().toISOString().split('T')[0];
        const todayCount = todaySessions.filter(s => s.date === today).length;
        
        // First session achievement
        if (allSessions.length === 1) {
            this.showNotification(
                'First Session Complete! 🎉',
                'You\'ve taken your first step towards better breathing habits.',
                'icons/icon48.png'
            );
        }
        
        // Daily milestones
        if (todayCount === 3) {
            this.showNotification(
                'Daily Goal Reached! ⭐',
                'You\'ve completed 3 sessions today. Keep up the great work!',
                'icons/icon48.png'
            );
        }
        
        // Weekly streak
        const weeklyStreak = this.calculateWeeklyStreak(allSessions);
        if (weeklyStreak === 7) {
            this.showNotification(
                'Weekly Streak! 🔥',
                'You\'ve practiced breathing exercises for 7 days straight!',
                'icons/icon48.png'
            );
        }
    }
    
    calculateWeeklyStreak(sessions) {
        const today = new Date();
        let streak = 0;
        
        for (let i = 0; i < 7; i++) {
            const checkDate = new Date(today);
            checkDate.setDate(today.getDate() - i);
            const dateStr = checkDate.toISOString().split('T')[0];
            
            const hasSessionOnDate = sessions.some(s => s.date === dateStr);
            if (hasSessionOnDate) {
                streak++;
            } else {
                break;
            }
        }
        
        return streak;
    }
    
    async setBreathingReminder(intervalMinutes) {
        chrome.alarms.create('breathingReminder', {
            delayInMinutes: intervalMinutes,
            periodInMinutes: intervalMinutes
        });
        
        await chrome.storage.local.set({
            reminderEnabled: true,
            reminderInterval: intervalMinutes
        });
    }
    
    async clearBreathingReminder() {
        chrome.alarms.clear('breathingReminder');
        
        await chrome.storage.local.set({
            reminderEnabled: false
        });
    }
    
    async showBreathingReminder() {
        const { reminderEnabled } = await chrome.storage.local.get(['reminderEnabled']);
        
        if (reminderEnabled) {
            this.showNotification(
                'Time to Breathe! 🧘‍♀️',
                'Take a moment for a quick breathing session to refresh your mind.',
                'icons/icon48.png'
            );
        }
    }
    
    async handleSessionComplete() {
        const { currentSession } = await chrome.storage.local.get(['currentSession']);
        
        if (currentSession) {
            this.showNotification(
                'Session Complete! ✨',
                `Great job! You completed your ${currentSession.duration}-minute breathing session.`,
                'icons/icon48.png'
            );
        }
    }
    
    
    showNotification(title, message, iconPath = 'icons/icon48.png') {
        chrome.notifications.create({
            type: 'basic',
            iconUrl: iconPath,
            title: title,
            message: message,
            priority: 1
        });
    }
    
    async initializeNotifications() {
        // Check if we should show daily reminder
        const { reminderEnabled, reminderInterval } = await chrome.storage.local.get([
            'reminderEnabled', 
            'reminderInterval'
        ]);
        
        if (reminderEnabled && reminderInterval) {
            this.setBreathingReminder(reminderInterval);
        }
    }
}

// Initialize background service
const breathingBackground = new BreathingBackground();