import { useOfArgs } from "../../../cache"

/** 创建一个 IndexedDB 包装，用来当做简单的 KV 存储，会复用 */
export const useIndexedKV = useOfArgs((dbName, storeName) => {
    return createIndexedKV(dbName, storeName)
})

/** 快捷的写入 IndexedDB 的值 */
export function setIndexedKV(dbName: string, storeName: string, key: any, value: any) {
    let kv = useIndexedKV(dbName, storeName)
    return kv.set(key, value)
}

/** 快捷的读取 IndexedDB 的值 */
export function getIndexedKV(dbName: string, storeName: string, key: any) {
    let kv = useIndexedKV(dbName, storeName)
    return kv.get(key)
}

/** 快捷的删除 IndexedDB 的值 */
export function deleteIndexedKV(dbName: string, storeName: string, key: any) {
    let kv = useIndexedKV(dbName, storeName)
    return kv.delete(key)
}

/** 快捷的获取全部 IndexedDB Keys */
export function keysIndexedKV(dbName: string, storeName: string) {
    let kv = useIndexedKV(dbName, storeName)
    return kv.keys()
}

/** 创建一个 IndexedDB 包装，用来当做简单的 KV 存储 */
function createIndexedKV(dbName: string, storeName: string) {
    let db: IDBDatabase
    let store: IDBObjectStore

    let openPs = new Promise<void>((resolve, reject) => {
        let req = indexedDB.open(dbName)
        req.onupgradeneeded = () => {
            db = req.result
            store = db.createObjectStore(storeName)
        }
        req.onsuccess = () => {
            db = req.result
            store = db.transaction(storeName, "readwrite").objectStore(storeName)
            resolve()
        }
        req.onerror = () => {
            reject(req.error)
        }
    })

    async function set(key: any, value: any) {
        await openPs
        return new Promise<void>((resolve, reject) => {
            let req = store.put(value, key)
            req.onsuccess = () => resolve()
            req.onerror = () => reject(req.error)
        })
    }

    async function get(key: any) {
        await openPs
        return new Promise<void>((resolve, reject) => {
            let req = store.get(key)
            req.onsuccess = () => resolve(req.result)
            req.onerror = () => reject(req.error)
        })
    }

    async function del(key: any) {
        await openPs
        return new Promise<void>((resolve, reject) => {
            let req = store.delete(key)
            req.onsuccess = () => resolve()
            req.onerror = () => reject(req.error)
        })
    }

    async function clear() {
        await openPs
        return new Promise<void>((resolve, reject) => {
            let req = store.clear()
            req.onsuccess = () => resolve()
            req.onerror = () => reject(req.error)
        })
    }

    async function close() {
        await openPs
        db.close()
    }

    async function forEach(callback: (value: any, key: any) => void) {
        await openPs
        return new Promise<void>((resolve, reject) => {
            let req = store.openCursor()
            req.onsuccess = () => {
                let cursor = req.result
                if (cursor) {
                    callback(cursor.value, cursor.key as string)
                    cursor.continue()
                } else {
                    resolve()
                }
            }
            req.onerror = () => reject(req.error)
        })
    }

    async function keys() {
        let keys: any[] = []
        await forEach((_, key) => {
            keys.push(key)
        })
        return keys
    }

    return { set, get, delete: del, clear, close, forEach, keys, dbName, storeName }
}