const lfetch = async (urls, url) => {
    let controller = new AbortController(); //针对此次请求新建一个AbortController,用于打断并发的其余请求
    const PauseProgress = async (res) => {
        //这个函数的作用时阻塞响应,直到主体被完整下载,避免被提前打断
        return new Response(await (res).arrayBuffer(), { status: res.status, headers: res.headers });
    };
    if (!Promise.any) { //Polyfill,避免Promise.any不存在,无需关注
        Promise.any = function (promises) {
            return new Promise((resolve, reject) => {
                promises = Array.isArray(promises) ? promises : []
                let len = promises.length
                let errs = []
                if (len === 0) return reject(new AggregateError('All promises were rejected'))
                promises.forEach((promise) => {
                    promise.then(value => {
                        resolve(value)
                    }, err => {
                        len--
                        errs.push(err)
                        if (len === 0) {
                            reject(new AggregateError(errs))
                        }
                    })
                })
            })
        }
    }
    return Promise.any(urls.map(urls => {//并发请求
        return new Promise((resolve, reject) => {
            fetch(urls, {
                signal: controller.signal//设置打断点
            })
                .then(PauseProgress)//阻塞当前响应直到下载完成
                .then(res => {
                    if (res.status == 200) {
                        controller.abort()//打断其余响应(同时也打断了自己的,但本身自己已下载完成,打断无效)
                        resolve(res)//返回
                    } else {
                        reject(res)
                    }
                })
        })
    }))
}

if(domain === "blog.cyfan.top"){//这里写你需要拦截的域名
    //从这里开始处理
}

const fullpath = (path) => {
    path = path.split('?')[0].split('#')[0]
    if (path.match(/\/$/)) {
        path += 'index'
    }
    if (!path.match(/\.[a-zA-Z]+$/)) {
        path += '.html'
    }
    return path
}

const generate_blog_urls = (packagename, blogversion, path) => {
    const npmmirror = [
        `https://unpkg.com/${packagename}@${blogversion}/public`,
        `https://npm.elemecdn.com/${packagename}@${blogversion}/public`,
        `https://cdn.jsdelivr.net/npm/${packagename}@${blogversion}/public`,
        `https://npm.sourcegcdn.com/npm/${packagename}@${blogversion}/public`,
        `https://cdn1.tianli0.top/npm/${packagename}@${blogversion}/public`
    ]
    for (var i in npmmirror) {
        npmmirror[i] += path
    }
    return npmmirror
}

if(domain === "blog.cyfan.top"){//这里写你需要拦截的域名
    return lfetch(generate_blog_urls('chenyfan-blog','1.1.4',fullpath(urlPath)))
}

if(domain === "blog.cyfan.top"){
    return lfetch(generate_blog_urls('chenyfan-blog','1.1.4',fullpath(urlPath)))
    .then(res=>res.arrayBuffer())//arrayBuffer最科学也是最快的返回
    .then(buffer=>new Response(buffer,{headers:{"Content-Type":"text/html;charset=utf-8"}}))//重新定义header
}

const mirror = [
        `https://registry.npmmirror.com/npm/chenyfan-blog/latest`,
        `https://registry.npmjs.org/chenyfan-blog/latest`,
        `https://mirrors.cloud.tencent.com/npm/chenyfan-blog/latest`
]
const get_newest_version = async (mirror) => {
    return lfetch(mirror, mirror[0])
        .then(res => res.json())
        .then(res.version)
}

self.db = { //全局定义db,只要read和write,看不懂可以略过
    read: (key, config) => {
        if (!config) { config = { type: "text" } }
        return new Promise((resolve, reject) => {
            caches.open(CACHE_NAME).then(cache => {
                cache.match(new Request(`https://LOCALCACHE/${encodeURIComponent(key)}`)).then(function (res) {
                    if (!res) resolve(null)
                    res.text().then(text => resolve(text))
                }).catch(() => {
                    resolve(null)
                })
            })
        })
    },
    write: (key, value) => {
        return new Promise((resolve, reject) => {
            caches.open(CACHE_NAME).then(function (cache) {
                cache.put(new Request(`https://LOCALCACHE/${encodeURIComponent(key)}`), new Response(value));
                resolve()
            }).catch(() => {
                reject()
            })
        })
    }
}

const set_newest_version = async (mirror) => { //改为最新版本写入数据库
    return lfetch(mirror, mirror[0])
        .then(res => res.json()) //JSON Parse
        .then(async res => {
            await db.write('blog_version', res.version) //写入
            return;
        })
}

setInterval(async() => {
    await set_newest_version(mirror) //定时更新,一分钟一次
}, 60*1000);

setTimeout(async() => { 
    await set_newest_version(mirror)//打开五秒后更新,避免堵塞
},5000)

generate_blog_urls('chenyfan-blog','1.1.4',fullpath(urlPath))

//若第一次没有,则使用初始版本1.1.4,或者你也可以改成latest(不推荐)
generate_blog_urls('chenyfan-blog',await db.read('blog_version') || '1.1.4',fullpath(urlPath))

const CACHE_NAME = 'cache-v1'; //定义缓存桶名称
caches.open(CACHE_NAME).then(async function (cache) {
    const KEYNAME = new Request('https://example.com/1.xxx') //定义KEY，[Object Request]
    await cache.put(KEYNAME, new Response('Hello World')); //自定义填入
    await cache.match(KEYNAME).then(async function (response) {
        console.log(await response.text()); //匹配并输出
    })
    await cache.put(KEYNAME, await fetch('https://example.com/2.xxx').then(res=>res.arrayBuffer())); //使用fetch填入缓存
    await cache.matchAll().then(function (responses) { //列出所有（也可以根据内容列出指定的项
        for (let response of responses) {
            console.log(response.url);
        }
    })
    await cache.delete(KEYNAME) //删除指定项
});

if (请求的网址是博客) {
    //这里一定要用Promise,这样在之后settimeout就不需要回调,直接Resolve
    return new Promise(function (resolve, reject) {
        setTimeout(async () => {
            if (存在缓存) {
                setTimeout(() => {
                    resolve(获取当前页面缓存(请求))
                }, 200);//200ms表示下面的拉取失败后直接返回缓存,但下面的拉取不会被踢出,更新会在后台执行,会填入缓存,但也不会返回
                setTimeout(() => {
                    resolve(
                        拉取最新版本的网页(请求)
                            .then(填入缓存并返回内容)//返回缓存
                    )
                }, 0);//表示立刻执行,优先级最高
            } else {
                setTimeout(() => {
                    resolve(
                        拉取最新版本的网页(请求)
                            .then(填入缓存并返回内容)//返回缓存
                    )
                }, 0);//表示立刻执行,优先级最高

                setTimeout(() => {
                    resolve(返回错误提示())
                }, 5000)//5000ms后如果没有返回最新内容就直接返回错误提示,如果成功了此次返回是无效的
            }
        }, 0)//这里需要一个大settimeout包裹以便于踢出主线程,否则无法并行处理

    })
}

(async () => {//使用匿名函数确保body已载入
    /*
    ChenBlogHelper_Set 存储在LocalStorage中,用于指示sw安装状态
    0 或不存在 未安装
    1 已打断
    2 已安装
    3 已激活,并且已缓存必要的文件(此处未写出,无需理会)
    */
    const $ = document.querySelector.bind(document);//语法糖
    if ('serviceWorker' in navigator) { //如果支持sw
        if (Number(window.localStorage.getItem('ChenBlogHelper_Set')) < 1) {
            window.localStorage.setItem('ChenBlogHelper_Set', 1)
            window.stop()
            document.write('Wait')
        }
        navigator.serviceWorker.register(`/sw.js?time=${ranN(1, 88888888888888888888)}`)//随机数,强制更新
            .then(async () => {
                if (Number(window.localStorage.getItem('ChenBlogHelper_Set')) < 2) {
                    setTimeout(() => {
                        window.localStorage.setItem('ChenBlogHelper_Set', 2)
                        //window.location.search = `?time=${ranN(1, 88888888888888888888)}` //已弃用,在等待500ms安装成功后直接刷新没有问题
                        window.location.reload()//刷新,以载入sw
                    }, 500)//安装后等待500ms使其激活
                }
            })
            .catch(err => console.error(`ChenBlogHelperError:${err}`))
    }
})()

document.body.innerHTML = await (await fetch('https://npm.elemecdn.com/[email protected]/public/notice.html')).text()