import { SlopDB, CheckCache } from "../scripts/indexed-db.js"
import { openDB, deleteDB } from "../scripts/idb/index.js"

const MAX_TIMESTAMP_DIFFERENCE = 3

let mock_clock = jasmine.clock().install()

describe("SlopDB", () => {

    let db

    beforeEach(async () => {
        await deleteDB("SlopDB")
    })

    afterEach(() => {
        db.close()
    })

    describe("version 1", () => {
        it("creates a version 1 indexeddb", async () => {
            const slopdb_v1 = new SlopDB(1)
            await slopdb_v1.db_opened()
            db = slopdb_v1.db

            const object_stores = slopdb_v1.db.objectStoreNames
            expect(object_stores).toContain("slop")
            expect(object_stores).not.toContain("checkcache")

            // slopdb_v1.db.close()
        })
    })

    describe("version 2", () => {

        let slopdb

        beforeAll(() => {
            mock_clock.mockDate(new Date(2020, 1, 1))
        })

        beforeEach(async () => {
            slopdb = new SlopDB(2)
            await slopdb.db_opened()
            db = slopdb.db
        })

        it("creates a version 2 indexeddb", async () => {

            const object_stores = slopdb.db.objectStoreNames
            expect(object_stores).toContain("slop")
            expect(object_stores).toContain("checkcache")

            // slopdb_v2.db.close()
        })

        
    })


})

describe("CheckCache", () => {
    let db
    let slopdb

    beforeAll(() => {
        mock_clock.mockDate(new Date(2020, 1, 1))
    })

    beforeEach(async () => {
        await deleteDB("SlopDB")
        slopdb = new SlopDB(2)
        await slopdb.db_opened()
        db = slopdb.db
    })
      
    afterEach(() => {
        db.close()
    })

    it("caches a checked url", async () => {
        const cache = slopdb.check_cache
        expect(cache).toBeInstanceOf(CheckCache)

        const slop_url = new URL("https://sloppy-slop.com/sloparticle")

        const new_item = await cache.store(slop_url.toString())
        const store_time = Date.now()

        mock_clock.tick(1000)
        const cached_item = await cache.get(slop_url.toString())

        expect(cached_item.url).toEqual(slop_url.toString())
        expect(new_item.check_timestamp).toBeCloseTo(store_time)
        expect(new_item.check_timestamp).toBeGreaterThan(store_time - MAX_TIMESTAMP_DIFFERENCE)
    })

    it("updates a cached url's timestamp when it is accessed", async () => {


        const cache = slopdb.check_cache

        const slop_url = new URL("https://sloppy-slop.com/sloparticle")
        await cache.store(slop_url.toString())
        const store_time = Date.now()

        mock_clock.tick(1000 * 30)

        const cached_item = await cache.get(slop_url.toString())
        expect(cached_item.check_timestamp).toBeGreaterThan(store_time + 10)
    })

    it("evicts the least recently accessed URL when an item is added to a full cache", async () => {
        const cache = slopdb.check_cache
        cache.cache_capacity = 2

        const slop_url = new URL("https://sloppy-slop.com/sloparticle")
        await cache.store(slop_url.toString())

        mock_clock.tick(1000)

        const slop_url2 = new URL("https://sloppy-slop.com/sloparticle2")
        await cache.store(slop_url2.toString())

        mock_clock.tick(1000)

        const slop_url3 = new URL("https://sloppy-slop.com/sloparticle3")
        await cache.store(slop_url3.toString())

        const get_slop1 = await cache.get(slop_url.toString())
        expect(get_slop1).toBeUndefined()
        expect(cache.size).toEqual(2)
    })
})

describe("SlopStore", () => {
    let db
    let slopdb

    beforeAll(() => {
        mock_clock.mockDate(new Date(2020, 1, 1))
    })

    beforeEach(async () => {
        await deleteDB("SlopDB")
        slopdb = new SlopDB(2)
        await slopdb.db_opened()
        db = slopdb.db
    })
      
    afterEach(() => {
        db.close()
    })

    it("stores slop", async () => {
        const stored = await slopdb.slop_store.store("its-slop.slop", "some/slop")
        expect(stored).toBe("its-slop.slop")

        const retrieved = await slopdb.slop_store.get(new URL("http://its-slop.slop/some/slop"))
        const expected_set = new Set()
        expected_set.add("some/slop")
        expect(retrieved).toEqual({domain: "its-slop.slop", paths: expected_set})
    })

    it("stores new slop paths to existing domains", async () => {
        const stored = await slopdb.slop_store.store("its-slop.slop", "some/slop")
        const new_path = await slopdb.slop_store.store("its-slop.slop", "some/other/slop")
        expect(new_path).toBe("its-slop.slop")

        const expected_set = new Set()
        expected_set.add("some/slop")
        expected_set.add("some/other/slop")

        const retrieved = await slopdb.slop_store.get(new URL("http://its-slop.slop/some/slop"))
        expect(retrieved).toEqual({domain: "its-slop.slop", paths: expected_set})
    })
})