/**
 * @file timer.js
 * @description Timer-funktionalitet för StatusNotifier Extension
 * 
 * Author: Linus Olofsson - Iver 
 * Date: 2025-07-03 
 * Last modified: Linus Olofsson (2025-07-08) - Synkronisering med service worker
 * 
 * @purpose Hantera timer-funktionalitet för automatisk uppdatering
 * @invoked_by popup.js
 * @invokes common/storage.js, components/itemList.js, chrome.runtime.sendMessage
 */

import { saveTimerSettings, getTimerSettings } from '../common/storage.js';
import { displayItems } from './itemList.js';

// Timer-variabler
let countdownInterval = null;
let countdownSeconds = 0;
let timerActive = false;
let timerEndTime = null;

// Starta timer med angivna timmar, minuter och sekunder
const startTimer = async (hours, minutes, seconds = 0) => {
    try {
        // Stoppa eventuell existerande timer
        stopTimer();
        
        // Beräkna totala millisekunder
        const totalMilliseconds = ((hours * 3600) + (minutes * 60) + seconds) * 1000;
        
        // Spara timer-inställningar
        await saveTimerSettings({ hours, minutes, seconds });
        
        console.log(`Requesting to start timer in service worker: ${hours}h ${minutes}m ${seconds}s (${totalMilliseconds}ms)`);
        
        // Skicka meddelande till service worker för att starta timer
        const response = await chrome.runtime.sendMessage({
            action: 'startTimer',
            duration: totalMilliseconds
        });
        
        console.log('Service worker response:', response);
        
        if (response && response.endTime) {
            // Sätt timer-variabler
            timerActive = true;
            timerEndTime = response.endTime;
            countdownSeconds = Math.ceil((timerEndTime - Date.now()) / 1000);
            
            // Uppdatera UI direkt
            updateTimerButton();
            
            // Starta lokal nedräkning för UI-uppdatering
            startLocalCountdown();
            
            console.log(`Timer started: ${hours}h ${minutes}m ${seconds}s, ends at ${new Date(timerEndTime).toLocaleTimeString()}`);
        } else {
            console.error('Failed to start timer in service worker');
        }
    } catch (error) {
        console.error('Error starting timer:', error);
    }
};

// Starta lokal nedräkning för UI-uppdatering
const startLocalCountdown = () => {
    // Rensa eventuell existerande interval
    if (countdownInterval) {
        clearInterval(countdownInterval);
    }
    
    // Starta intervall för nedräkning (endast för UI-uppdatering)
    countdownInterval = setInterval(() => {
        if (!timerActive) {
            clearInterval(countdownInterval);
            countdownInterval = null;
            return;
        }
        
        // Beräkna återstående tid
        const now = Date.now();
        const remaining = timerEndTime - now;
        
        if (remaining > 0) {
            countdownSeconds = Math.ceil(remaining / 1000);
            updateTimerButton();
        } else {
            // När timern når noll
            countdownSeconds = 0;
            updateTimerButton();
            clearInterval(countdownInterval);
            countdownInterval = null;
            timerActive = false;
            timerEndTime = null;
            
            // Uppdatera listan när timern når noll - hämta via service worker (inga flikar)
            chrome.runtime.sendMessage({ action: 'checkItems' }).then(() => {
                displayItems();
            }).catch(err => console.error('Error refreshing items:', err));
        }
    }, 1000);
};

// Stoppa timer
const stopTimer = async () => {
    try {
        // Stoppa lokal nedräkning
        if (countdownInterval) {
            clearInterval(countdownInterval);
            countdownInterval = null;
        }
        
        // Skicka meddelande till service worker för att stoppa timer
        const response = await chrome.runtime.sendMessage({
            action: 'stopTimer'
        });
        
        console.log('Stop timer response from service worker:', response);
        
        // Återställ timer-variabler
        timerActive = false;
        timerEndTime = null;
        countdownSeconds = 0;
        
        // Uppdatera UI
        updateTimerButton();
        
        console.log('Timer stopped');
    } catch (error) {
        console.error('Error stopping timer:', error);
    }
};

// Pausa timer - inte implementerad i service worker
const pauseTimer = () => {
    console.log('Pause timer not implemented in service worker mode');
};

// Återuppta timer - inte implementerad i service worker
const resumeTimer = () => {
    console.log('Resume timer not implemented in service worker mode');
};

// Hantera timer-slut - hanteras nu av service worker
const handleTimerEnd = async () => {
    try {
        console.log('Timer ended, refreshing items...');
        
        // Uppdatera listan via service worker (inga flikar)
        await chrome.runtime.sendMessage({ action: 'checkItems' });
        await displayItems();
        
        // Hämta sparade timer-inställningar och starta om timern
        const settings = await getTimerSettings();
        if (settings && (settings.hours > 0 || settings.minutes > 0 || settings.seconds > 0)) {
            // Kort fördröjning innan omstart för att säkerställa att UI hinner uppdateras
            setTimeout(() => {
                startTimer(settings.hours, settings.minutes, settings.seconds || 0);
            }, 1000);
        }
    } catch (error) {
        console.error('Error handling timer end:', error);
    }
};

// Uppdatera timer-knappen med aktuell nedräkning
const updateTimerButton = () => {
    const timerDisplay = document.getElementById('timerDisplay');
    const timerBtn = document.getElementById('timerBtn');
    const timerIcon = timerBtn ? timerBtn.querySelector('.btn-icon') : null;
    if (!timerDisplay) return;
    
    if (timerActive) {
        const minutes = Math.floor(countdownSeconds / 60);
        const seconds = countdownSeconds % 60;
        const timeStr = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
        timerDisplay.textContent = timeStr;
        if (timerIcon) timerIcon.textContent = timeStr;
    } else {
        timerDisplay.textContent = 'Timer';
        if (timerIcon) timerIcon.textContent = '\u23F1';
    }
};

// Hämta timer-status från service worker
const getTimerStatus = async () => {
    try {
        const response = await chrome.runtime.sendMessage({
            action: 'getTimerStatus'
        });
        
        console.log('Timer status from service worker:', response);
        
        if (response) {
            // Uppdatera lokala variabler
            timerActive = response.active;
            timerEndTime = response.endTime;
            
            if (timerActive && timerEndTime) {
                countdownSeconds = Math.ceil((timerEndTime - Date.now()) / 1000);
                
                // Starta lokal nedräkning om den inte redan körs
                if (!countdownInterval && timerActive) {
                    startLocalCountdown();
                }
            } else {
                countdownSeconds = 0;
            }
            
            // Uppdatera UI
            updateTimerButton();
            
            return {
                active: timerActive,
                remainingSeconds: countdownSeconds,
                endTime: timerEndTime
            };
        }
        
        return {
            active: false,
            remainingSeconds: 0,
            endTime: null
        };
    } catch (error) {
        console.error('Error getting timer status:', error);
        return {
            active: false,
            remainingSeconds: 0,
            endTime: null
        };
    }
};

// Starta timer från sparade inställningar eller återuppta befintlig timer
const startTimerFromStorage = async () => {
    try {
        console.log('Checking for active timer or starting from storage settings...');
        
        // Kontrollera om det finns en aktiv timer i service worker
        const status = await getTimerStatus();
        
        if (status.active) {
            console.log(`Active timer found in service worker, remaining: ${status.remainingSeconds}s`);
            // Timer är redan aktiv, uppdatera UI och starta lokal nedräkning
            timerActive = true;
            timerEndTime = status.endTime;
            countdownSeconds = status.remainingSeconds;
            
            // Starta lokal nedräkning om den inte redan körs
            if (!countdownInterval) {
                startLocalCountdown();
            }
            
            // Uppdatera UI
            updateTimerButton();
            return;
        } else {
            // Kontrollera om timern har löpt ut medan popup var stängd
            const storageResult = await chrome.storage.local.get(['timerExpiredWhileClosed']);
            if (storageResult.timerExpiredWhileClosed) {
                console.log('Timer expired while popup was closed, updating items...');
                
                // Uppdatera listan från storage (service worker har redan hämtat data)
                await displayItems();
                
                // Återställ flaggan
                await chrome.storage.local.set({ timerExpiredWhileClosed: false });
            }
        }
        
        // Ingen aktiv timer, kontrollera sparade inställningar
        const settings = await getTimerSettings();
        if (settings && (settings.hours > 0 || settings.minutes > 0 || settings.seconds > 0)) {
            // Om vi har en återkommande timer-inställning, starta en ny timer
            const recurringResult = await chrome.storage.local.get(['recurringTimer']);
            if (recurringResult.recurringTimer) {
                console.log(`Starting recurring timer: ${settings.hours}h ${settings.minutes}m ${settings.seconds || 0}s`);
                await startTimer(settings.hours, settings.minutes, settings.seconds || 0);
            } else {
                console.log(`Timer settings found but not starting automatically: ${settings.hours}h ${settings.minutes}m ${settings.seconds || 0}s`);
            }
        } else {
            console.log('No valid timer settings found in storage');
        }
    } catch (error) {
        console.error('Error starting timer from storage:', error);
    }
};

// Initiera timer-funktionalitet och lyssna efter uppdateringar från service worker
const initTimer = async () => {
    try {
        console.log('Initializing timer functionality with service worker...');
        
        // Kontrollera att timer-knappen finns
        const timerButton = document.getElementById('timerBtn');
        if (!timerButton) {
            console.error('Timer button not found in DOM');
            return false;
        }
        
        // Verifiera att Service Worker är aktiv och kontrollerar popup
        if (navigator.serviceWorker.controller) {
            console.log("SW is controlling this context", navigator.serviceWorker.controller);
        } else {
            console.error("No active Service Worker is controlling this page");
            // Försök registrera service worker om den inte kontrollerar sidan
            try {
                await navigator.serviceWorker.register('/javascript/background/serviceWorker.js');
                console.log('SW registered');
                // Reload kan behövas för att säkerställa kontroll
                if (!navigator.serviceWorker.controller) {
                    console.warn('Reloading page to ensure SW control');
                    location.reload();
                    return false;
                }
            } catch (err) {
                console.error('Failed to register SW:', err);
            }
        }
        
        // Lyssna efter meddelanden från service worker
        chrome.runtime.onMessage.addListener((message) => {
            if (message.action === 'timerUpdate') {
                console.log('Received timer update from service worker:', message);
                
                // Uppdatera lokala variabler
                timerActive = message.active;
                
                if (message.remaining > 0) {
                    countdownSeconds = Math.ceil(message.remaining / 1000);
                    timerEndTime = Date.now() + message.remaining;
                } else {
                    countdownSeconds = 0;
                    timerEndTime = null;
                }
                
                // Uppdatera UI
                updateTimerButton();
            }
            else if (message.action === 'itemsUpdated') {
                console.log('Items updated by service worker, refreshing list');
                // Uppdatera listan från storage (inga flikar)
                displayItems();
            }
        });
        
        // Kontrollera om det finns en aktiv timer i service worker
        await startTimerFromStorage();
        
        console.log('Timer functionality initialized with service worker');
        return true;
    } catch (error) {
        console.error('Error initializing timer with service worker:', error);
        return false;
    }
};

// Exportera funktioner
export {
    startTimer,
    stopTimer,
    pauseTimer,
    resumeTimer,
    updateTimerButton,
    getTimerStatus,
    startTimerFromStorage,
    initTimer
};
