/*******************************************************************************

    uBlock Origin - a comprehensive, efficient content blocker
    Copyright (C) 2014-present Raymond Hill

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see {http://www.gnu.org/licenses/}.

    Home: https://github.com/gorhill/uBlock
*/

import { dom, qs$ } from './dom.js';

/******************************************************************************/

dom.cl.remove(dom.body, 'notReady');

const allowedDashboardPanes = new Set([
    'settings.html',
    '3p-filters.html',
    'diagnostics.html',
    'about.html',
    'no-dashboard.html',
]);

const normalizeDashboardPane = pane =>
    allowedDashboardPanes.has(pane) ? pane : 'settings.html';

function discardUnsavedData(synchronous = false) {
    const paneFrame = qs$('#iframe');
    if ( paneFrame === null ) { return true; }
    const paneWindow = paneFrame.contentWindow;
    if (
        typeof paneWindow.hasUnsavedData !== 'function' ||
        paneWindow.hasUnsavedData() === false
    ) {
        return true;
    }

    if ( synchronous ) {
        return false;
    }

    return new Promise(resolve => {
        const modal = qs$('#unsavedWarning');
        dom.cl.add(modal, 'on');
        modal.focus();

        const onDone = status => {
            dom.cl.remove(modal, 'on');
            dom.off(document, 'click', onClick, true);
            resolve(status);
        };

        const onClick = ev => {
            const target = ev.target;
            if ( target.matches('[data-i18n="dashboardUnsavedWarningStay"]') ) {
                return onDone(false);
            }
            if ( target.matches('[data-i18n="dashboardUnsavedWarningIgnore"]') ) {
                return onDone(true);
            }
            if ( qs$(modal, '[data-i18n="dashboardUnsavedWarning"]').contains(target) ) {
                return;
            }
            onDone(false);
        };

        dom.on(document, 'click', onClick, true);
    });
}

function loadDashboardPanel(pane, first) {
    pane = normalizeDashboardPane(pane);
    const tabButton = qs$(`[data-pane="${pane}"]`);
    if ( tabButton === null || dom.cl.has(tabButton, 'selected') ) { return; }
    const loadPane = ( ) => {
        self.location.replace(`#${pane}`);
        dom.cl.remove('.tabButton.selected', 'selected');
        dom.cl.add(tabButton, 'selected');
        tabButton.scrollIntoView();
        const iframe = qs$('#iframe');
        if ( iframe === null || iframe.contentWindow === null ) { return; }
        iframe.contentWindow.location.replace(pane);
        if ( pane !== 'no-dashboard.html' ) {
            iframe.addEventListener('load', ( ) => {
                const wikilink = qs$('.wikilink');
                if ( wikilink !== null ) {
                    wikilink.href = iframe.contentWindow.wikilink || '';
                }
            }, { once: true });
            vAPI.localStorage.setItem('dashboardLastVisitedPane', pane);
        }
    };
    if ( first ) {
        return loadPane();
    }
    const r = discardUnsavedData();
    if ( r === false ) { return; }
    if ( r === true ) { return loadPane(); }
    r.then(status => {
        if ( status === false ) { return; }
        loadPane();
    });
}

function onTabClickHandler(ev) {
    loadDashboardPanel(dom.attr(ev.target, 'data-pane'));
}

if ( self.location.hash.slice(1) === 'no-dashboard.html' ) {
    dom.cl.add(dom.body, 'noDashboard');
}

dom.on('.tabButton', 'click', onTabClickHandler);

const withTimeout = async (promise, fallback, delay = 1500) => {
    try {
        return await Promise.race([
            promise,
            vAPI.defer.once(delay).then(( ) => fallback),
        ]);
    } catch {
        return fallback;
    }
};

const waitUntilReadyToFilter = async ( ) => {
    for ( let i = 0; i < 40; i++ ) {
        try {
            const response = await withTimeout(
                vAPI.messaging.send('dashboard', { what: 'readyToFilter' }),
                false,
                1000
            );
            if ( response ) { return true; }
        } catch {
        }
        await vAPI.defer.once(250);
    }
    return false;
};

(async ( ) => {
    let pane = normalizeDashboardPane(self.location.hash.slice(1) || 'settings.html');
    loadDashboardPanel(pane, true);

    await waitUntilReadyToFilter();

    const results = await Promise.all([
        // https://github.com/uBlockOrigin/uBlock-issues/issues/106
        withTimeout(vAPI.messaging.send('dashboard', { what: 'dashboardConfig' }), {}),
        withTimeout(vAPI.localStorage.getItemAsync('dashboardLastVisitedPane'), null),
    ]);

    {
        const details = results[0] || {};
        if ( details.noDashboard ) {
            self.location.hash = '#no-dashboard.html';
            dom.cl.add(dom.body, 'noDashboard');
        } else if ( self.location.hash === '#no-dashboard.html' ) {
            self.location.hash = '';
        }
    }

    {
        pane = results[1] || null;
        if ( self.location.hash !== '' ) {
            pane = normalizeDashboardPane(self.location.hash.slice(1) || null);
        }
        loadDashboardPanel(normalizeDashboardPane(pane !== null ? pane : 'settings.html'), true);

        // https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
        dom.on(self, 'beforeunload', ev => {
            if ( discardUnsavedData(true) ) { return; }
            ev.preventDefault();
            ev.returnValue = '';
        });

        // https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
        dom.on(self, 'hashchange', ( ) => {
            const pane = normalizeDashboardPane(self.location.hash.slice(1));
            if ( pane === '' ) { return; }
            loadDashboardPanel(pane);
        });

    }
})();
