export {};

type AnalyticsEvent = 'pageview' | 'page_update' | 'session_end' | 'conversion';

type AnalyticsPayload = {
    event: AnalyticsEvent;
    sessionToken: string;
    visitorToken: string;
    pageToken?: string;
    path: string;
    title?: string;
    referrer?: string;
    deviceType: string;
    locale?: string;
    timeOnPageSeconds?: number;
    scrollDepthPercent?: number;
    exitReason?: string;
    conversionType?: string;
};

type SftAnalyticsApi = {
    trackConversion: (conversionType?: string) => void;
};

declare global {
    interface Window {
        sftAnalytics?: SftAnalyticsApi;
    }
}

const COLLECT_URL = '/analytics/collect';
const VISITOR_KEY = 'sft_analytics_vid';
const SESSION_KEY = 'sft_analytics_sid';
const HEARTBEAT_MS = 15000;
const CONVERSION_FLAG_KEY = 'sft_analytics_converted';

function hasAnalyticsConsent(): boolean {
    return document.cookie.includes('cookie_analytics=true');
}

function createToken(): string {
    if (window.crypto?.randomUUID) {
        return window.crypto.randomUUID().replace(/-/g, '');
    }

    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
}

function readStorage(key: string, storage: Storage): string | null {
    try {
        return storage.getItem(key);
    } catch {
        return null;
    }
}

function writeStorage(key: string, value: string, storage: Storage): void {
    try {
        storage.setItem(key, value);
    } catch {
        // ignore quota / private mode
    }
}

function getVisitorToken(): string {
    let token = readStorage(VISITOR_KEY, localStorage);
    if (!token) {
        token = createToken();
        writeStorage(VISITOR_KEY, token, localStorage);
    }

    return token;
}

function getSessionToken(): string {
    let token = readStorage(SESSION_KEY, sessionStorage);
    if (!token) {
        token = createToken();
        writeStorage(SESSION_KEY, token, sessionStorage);
    }

    return token;
}

function detectDevice(): string {
    const ua = navigator.userAgent || '';
    if (/iPad|Tablet/i.test(ua)) {
        return 'tablet';
    }
    if (/Mobi|Android|iPhone/i.test(ua)) {
        return 'mobile';
    }

    return 'desktop';
}

function shouldSkipPath(path: string): boolean {
    return (
        path.startsWith('/adm')
        || path.startsWith('/build')
        || path.startsWith('/analytics')
        || path.startsWith('/_profiler')
        || path.startsWith('/_wdt')
    );
}

function send(payload: AnalyticsPayload, preferBeacon = false): void {
    const body = JSON.stringify(payload);

    if (preferBeacon && navigator.sendBeacon) {
        const blob = new Blob([body], {type: 'application/json'});
        navigator.sendBeacon(COLLECT_URL, blob);
        return;
    }

    fetch(COLLECT_URL, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body,
        keepalive: true,
        credentials: 'same-origin',
    }).catch(() => {
        // ignore network errors
    });
}

function scrollDepthPercent(): number {
    const doc = document.documentElement;
    const scrollTop = window.scrollY || doc.scrollTop || 0;
    const height = Math.max(doc.scrollHeight - window.innerHeight, 1);

    return Math.min(100, Math.round((scrollTop / height) * 100));
}

function buildBasePayload(pageToken?: string, startedAt?: number, maxScroll?: number): Omit<AnalyticsPayload, 'event'> {
    return {
        sessionToken: getSessionToken(),
        visitorToken: getVisitorToken(),
        pageToken,
        path: window.location.pathname || '/',
        title: document.title || undefined,
        referrer: document.referrer || undefined,
        deviceType: detectDevice(),
        locale: document.documentElement.lang || undefined,
        timeOnPageSeconds: startedAt
            ? Math.max(0, Math.round((Date.now() - startedAt) / 1000))
            : undefined,
        scrollDepthPercent: maxScroll,
    };
}

function trackConversion(conversionType = 'upload'): void {
    if (!hasAnalyticsConsent()) {
        return;
    }

    const path = window.location.pathname || '/';
    if (shouldSkipPath(path)) {
        return;
    }

    const sessionToken = getSessionToken();
    const flagKey = `${CONVERSION_FLAG_KEY}_${sessionToken}_${conversionType}`;
    if (readStorage(flagKey, sessionStorage) === '1') {
        return;
    }
    writeStorage(flagKey, '1', sessionStorage);

    send({
        event: 'conversion',
        ...buildBasePayload(),
        conversionType,
    });
}

function bootAnalytics(): void {
    if (!hasAnalyticsConsent()) {
        return;
    }

    const path = window.location.pathname || '/';
    if (shouldSkipPath(path)) {
        return;
    }

    const pageToken = createToken();
    const startedAt = Date.now();
    let maxScroll = scrollDepthPercent();
    let ended = false;

    const base = (): Omit<AnalyticsPayload, 'event'> => buildBasePayload(pageToken, startedAt, maxScroll);

    send({
        event: 'pageview',
        ...base(),
    });

    const onScroll = (): void => {
        maxScroll = Math.max(maxScroll, scrollDepthPercent());
    };
    window.addEventListener('scroll', onScroll, {passive: true});

    const heartbeat = window.setInterval(() => {
        if (document.visibilityState === 'hidden') {
            return;
        }
        send({
            event: 'page_update',
            ...base(),
        });
    }, HEARTBEAT_MS);

    const endSession = (reason: string): void => {
        if (ended) {
            return;
        }
        ended = true;
        window.clearInterval(heartbeat);
        window.removeEventListener('scroll', onScroll);
        send({
            event: 'session_end',
            ...base(),
            exitReason: reason,
        }, true);
    };

    // pagehide fires when the user leaves the page (close tab, navigate away, reload).
    window.addEventListener('pagehide', () => endSession('page_leave'));
    document.addEventListener('visibilitychange', () => {
        if (document.visibilityState === 'hidden') {
            send({
                event: 'page_update',
                ...base(),
            }, true);
        }
    });
}

function init(): void {
    window.sftAnalytics = {trackConversion};

    bootAnalytics();
    window.addEventListener('cookie-consent-updated', ((event: CustomEvent<{analytics?: boolean}>) => {
        if (event.detail?.analytics || hasAnalyticsConsent()) {
            bootAnalytics();
        }
    }) as EventListener);
}

if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', init);
} else {
    init();
}
