import { assert, spy, use } from "chai"
import * as spies from "chai-spies"

import { Ocean } from "../../src/ocean/Ocean"
import { Aquarius } from "../../src/aquarius/Aquarius"
import { SearchQuery } from "../../src/aquarius/Aquarius"
import { DDO } from "../../src/ddo/DDO"
import DID from "../../src/ocean/DID"
import config from "../config"

use(spies)

const reponsify = async data => ({ok: true, json: () => Promise.resolve(data)})

describe("Aquarius", () => {

    let ocean: Ocean
    let aquarius: Aquarius
    // tslint:disable-next-line
    const getResults = (results: DDO[], page = 0, total_pages = 1, total_results = 1) =>
        ({results, page, total_pages, total_results})

    beforeEach(async () => {
        ocean = await Ocean.getInstance(config)
        aquarius = ocean.aquarius
    })

    afterEach(() => {
        spy.restore()
    })

    describe("#queryMetadata()", () => {

        const query = {
            offset: 100,
            page: 1,
            query: {
                value: 1,
            },
            sort: {
                value: 1,
            },
            text: "Office",
        } as SearchQuery

        it("should query metadata", async () => {
            spy.on(ocean.utils.fetch, 'post', () => reponsify(getResults([new DDO()])))

            const result = await aquarius.queryMetadata(query)
            assert.typeOf(result.results, "array")
            assert.lengthOf(result.results, 1)
            assert.equal(result.page, 0)
            assert.equal(result.totalPages, 1)
            assert.equal(result.totalResults, 1)
        })

        it("should query metadata and return real ddo", async () => {

            spy.on(ocean.utils.fetch, 'post', () => reponsify(getResults([new DDO()])))

            const result = await aquarius.queryMetadata(query)
            assert.typeOf(result.results, "array")
            assert.lengthOf(result.results, 1)
            assert.isDefined(result.results[0].findServiceById)
        })
    })

    describe("#queryMetadataByText()", () => {

        const query = {
            offset: 100,
            page: 1,
            query: {
                value: 1,
            },
            sort: {
                value: 1,
            },
            text: "Office",
        } as SearchQuery

        it("should query metadata by text", async () => {

            spy.on(ocean.utils.fetch, 'get', () => reponsify(getResults([new DDO()])))

            const result = await aquarius.queryMetadataByText(query)
            assert.typeOf(result.results, "array")
            assert.lengthOf(result.results, 1)
            assert.equal(result.page, 0)
            assert.equal(result.totalPages, 1)
            assert.equal(result.totalResults, 1)
        })

        it("should query metadata and return real ddo", async () => {

            spy.on(ocean.utils.fetch, 'get', () => reponsify(getResults([new DDO()])))

            const result = await aquarius.queryMetadataByText(query)
            assert.typeOf(result.results, "array")
            assert.lengthOf(result.results, 1)
            assert.isDefined(result.results[0].findServiceById)
        })

    })

    describe("#storeDDO()", () => {

        it("should store a ddo", async () => {

            const did: DID = DID.generate()
            const ddo: DDO = new DDO({
                id: did.getId(),
            })

            spy.on(ocean.utils.fetch, 'post', () => reponsify(ddo))

            const result: DDO = await aquarius.storeDDO(ddo)
            assert(result)
            assert(result.id === ddo.id)
        })
    })

    describe("#retrieveDDO()", () => {

        it("should store a ddo", async () => {

            const did: DID = DID.generate()
            const ddo: DDO = new DDO({
                id: did.getId(),
            })

            spy.on(ocean.utils.fetch, 'post', () => reponsify(ddo))
            spy.on(ocean.utils.fetch, 'get', () => reponsify(ddo))

            const storageResult: DDO = await aquarius.storeDDO(ddo)
            assert(storageResult)

            assert(storageResult.id === did.getId())

            const restrieveResult: DDO = await aquarius.retrieveDDO(did)
            assert(restrieveResult)

            assert(restrieveResult.id === did.getId())
            assert(restrieveResult.id === storageResult.id)
        })
    })
})