/// <reference lib="webworker" />
import { IDBPDatabase, openDB } from "idb";
import { getItem } from "localforage";
import { Channel, Message, User } from "revolt.js";
import { Server } from "revolt.js/dist/api/objects";
import { precacheAndRoute } from "workbox-precaching";

import type { State } from "./redux";
import {
    getNotificationState,
    shouldNotify,
} from "./redux/reducers/notifications";

declare let self: ServiceWorkerGlobalScope;

self.addEventListener("message", (event) => {
    if (event.data && event.data.type === "SKIP_WAITING") self.skipWaiting();
});

precacheAndRoute(self.__WB_MANIFEST);

// ulid decodeTime(id: string)
// since crypto is not available in sw.js
const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
const ENCODING_LEN = ENCODING.length;
const TIME_LEN = 10;

function decodeTime(id: string) {
    var time = id
        .substr(0, TIME_LEN)
        .split("")
        .reverse()
        .reduce(function (carry, char, index) {
            var encodingIndex = ENCODING.indexOf(char);
            if (encodingIndex === -1) throw "invalid character found: " + char;

            return (carry += encodingIndex * Math.pow(ENCODING_LEN, index));
        }, 0);

    return time;
}

self.addEventListener("push", (event) => {
    async function process() {
        if (event.data === null) return;
        let data: Message = event.data.json();

        let item = await localStorage.getItem("state");
        if (!item) return;

        const state: State = JSON.parse(item);
        const autumn_url = state.config.features.autumn.url;
        const user_id = state.auth.active!;

        let db: IDBPDatabase;
        try {
            // Match RevoltClient.tsx#L55
            db = await openDB("state", 3, {
                upgrade(db) {
                    for (let store of [
                        "channels",
                        "servers",
                        "users",
                        "members",
                    ]) {
                        db.createObjectStore(store, {
                            keyPath: "_id",
                        });
                    }
                },
            });
        } catch (err) {
            console.error(
                "Failed to open IndexedDB store, continuing without.",
            );
            return;
        }

        async function get<T>(
            store: string,
            key: string,
        ): Promise<T | undefined> {
            try {
                return await db.get(store, key);
            } catch (err) {
                return undefined;
            }
        }

        let channel = await get<Channel>("channels", data.channel);
        let user = await get<User>("users", data.author);

        if (channel) {
            const notifs = getNotificationState(state.notifications, channel);
            if (!shouldNotify(notifs, data, user_id)) return;
        }

        let title = `@${data.author}`;
        let username = user?.username ?? data.author;
        let image;
        if (data.attachments) {
            let attachment = data.attachments[0];
            if (attachment.metadata.type === "Image") {
                image = `${autumn_url}/${attachment.tag}/${attachment._id}`;
            }
        }

        switch (channel?.channel_type) {
            case "SavedMessages":
                break;
            case "DirectMessage":
                title = `@${username}`;
                break;
            case "Group":
                if (user?._id === "00000000000000000000000000") {
                    title = channel.name;
                } else {
                    title = `@${user?.username} - ${channel.name}`;
                }
                break;
            case "TextChannel":
                {
                    let server = await get<Server>("servers", channel.server);
                    title = `@${user?.username} (#${channel.name}, ${server?.name})`;
                }
                break;
        }

        await self.registration.showNotification(title, {
            icon: user?.avatar
                ? `${autumn_url}/${user.avatar.tag}/${user.avatar._id}`
                : `https://api.revolt.chat/users/${data.author}/default_avatar`,
            image,
            body:
                typeof data.content === "string"
                    ? data.content
                    : JSON.stringify(data.content),
            timestamp: decodeTime(data._id),
            tag: data.channel,
            badge: "https://app.revolt.chat/assets/icons/android-chrome-512x512.png",
            data:
                channel?.channel_type === "TextChannel"
                    ? `/server/${channel.server}/channel/${channel._id}`
                    : `/channel/${data.channel}`,
        });
    }

    event.waitUntil(process());
});

// ? Open the app on notification click.
// https://stackoverflow.com/a/39457287
self.addEventListener("notificationclick", function (event) {
    let url = event.notification.data;
    event.notification.close();
    event.waitUntil(
        self.clients
            .matchAll({ includeUncontrolled: true, type: "window" })
            .then((windowClients) => {
                // Check if there is already a window/tab open with the target URL
                for (var i = 0; i < windowClients.length; i++) {
                    var client = windowClients[i];
                    // If so, just focus it.
                    if (client.url === url && "focus" in client) {
                        return client.focus();
                    }
                }

                // If not, then open the target URL in a new window/tab.
                if (self.clients.openWindow) {
                    return self.clients.openWindow(url);
                }
            }),
    );
});