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

import { DDO } from "../../src/ddo/DDO"
import { Service } from "../../src/ddo/Service"
import { Ocean } from "../../src/ocean/Ocean"
import config from "../config"
import TestContractHandler from "../keeper/TestContractHandler"

import * as jsonDDO from "../testdata/ddo.json"

use(spies)

describe("DDO", () => {

    const testDDO: DDO = new DDO({
        id: `did:op:${"a".repeat(64)}`,
        publicKey: [
            {
                id: "did:op:123456789abcdefghi#keys-1",
                type: "RsaVerificationKey2018",
                owner: "did:op:123456789abcdefghi",
                publicKeyPem: "-----BEGIN PUBLIC KEY...END PUBLIC KEY-----\r\n",
            },
            {
                id: "did:op:123456789abcdefghi#keys-2",
                type: "Ed25519VerificationKey2018",
                owner: "did:op:123456789abcdefghi",
                publicKeyBase58: "H3C2AVvLMv6gmMNam3uVAjZpfkcJCwDwnZn6z3wXmqPV",
            },
        ],
        authentication: [
            {
                type: "RsaSignatureAuthentication2018",
                publicKey: "did:op:123456789abcdefghi#keys-1",
            },
            {
                type: "ieee2410Authentication2018",
                publicKey: "did:op:123456789abcdefghi#keys-2",
            },
        ],
        service: [
            {
                type: "OpenIdConnectVersion1.0Service",
                serviceEndpoint: "https://openid.example.com/",
            },
            {
                type: "CredentialRepositoryService",
                serviceEndpoint: "https://repository.example.com/service/8377464",
            },
            {
                type: "XdiService",
                serviceEndpoint: "https://xdi.example.com/8377464",
            },
            {
                type: "HubService",
                serviceEndpoint: "https://hub.example.com/.identity/did:op:0123456789abcdef/",
            },
            {
                type: "MessagingService",
                serviceEndpoint: "https://example.com/messages/8377464",
            },
            {
                type: "SocialWebInboxService",
                serviceEndpoint: "https://social.example.com/83hfh37dj",
                description: "My public social inbox",
                spamCost: {
                    amount: "0.50",
                    currency: "USD",
                },
            } as any,
            {
                id: "did:op:123456789abcdefghi;bops",
                type: "BopsService",
                serviceEndpoint: "https://bops.example.com/enterprise/",
            },
            {
                type: "Consume",
                serviceEndpoint: "http://mybrizo.org/api/v1/brizo/services/consume?pubKey=${pubKey}&serviceId={serviceId}&url={url}",
            },
            {
                type: "Compute",
                // tslint:disable-next-line
                serviceEndpoint: "http://mybrizo.org/api/v1/brizo/services/compute?pubKey=${pubKey}&serviceId={serviceId}&algo={algo}&container={container}",
            },
            {
                type: "Metadata",
                serviceEndpoint: "http://myaquarius.org/api/v1/provider/assets/metadata/{did}",
                metadata: {
                    base: {
                        name: "UK Weather information 2011",
                        type: "dataset",
                        description: "Weather information of UK including temperature and humidity",
                        dateCreated: "2012-10-10T17:00:000Z",
                        datePublished: "2012-10-10T17:00:000Z",
                        author: "Met Office",
                        license: "CC-BY",
                        copyrightHolder: "Met Office",
                        workExample: "423432fsd,51.509865,-0.118092,2011-01-01T10:55:11+00:00,7.2,68",
                        links: [
                            {
                                sample1: "http://data.ceda.ac.uk/badc/ukcp09/data/gridded-land-obs/gridded-land-obs-daily/",
                            },
                            {
                                sample2: "http://data.ceda.ac.uk/badc/ukcp09/data/gridded-land-obs/gridded-land-obs-averages-25km/",
                            },
                            {
                                fieldsDescription: "http://data.ceda.ac.uk/badc/ukcp09/",
                            },
                        ],
                        inLanguage: "en",
                        categories: ["Economy", "Data Science"],
                        tags: ["weather", "uk", "2011", "temperature", "humidity"],
                        price: 10,
                        files: [
                            {
                                index: 0,
                                checksum: "efb2c764274b745f5fc37f97c6b0e761",
                                contentLength: 4535431,
                                resourceId: "access-log2018-02-13-15-17-29-18386C502CAEA932",
                            },
                            {
                                index: 1,
                                checksum: "085340abffh21495345af97c6b0e761",
                                contentLength: 12324,
                            },
                            {
                                index: 2,
                            },
                        ],
                        checksum: "",
                    },
                    curation: {
                        rating: 0.93,
                        numVotes: 123,
                        schema: "Binary Voting",
                    },
                    additionalInformation: {
                        updateFrecuency: "yearly",
                        structuredMarkup: [
                            {
                                uri: "http://skos.um.es/unescothes/C01194/jsonld",
                                mediaType: "application/ld+json",
                            },
                            {
                                uri: "http://skos.um.es/unescothes/C01194/turtle",
                                mediaType: "text/turtle",
                            },
                        ],
                    },
                },
            },
        ],
    })

    let web3: Web3
    let ocean: Ocean

    beforeEach(async () => {
        await TestContractHandler.prepareContracts()
        ocean = await Ocean.getInstance(config)
        web3 = (ocean as any).web3
    })

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

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

        it("should properly serialize", async () => {

            const ddoString = DDO.serialize(testDDO)
            assert(ddoString)
            assert(ddoString.startsWith("{"))
        })
    })

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

        it("should create an empty ddo", async () => {

            const ddo = new DDO()
            assert(ddo)

            assert(ddo.service.length === 0)
            assert(ddo.authentication.length === 0)
            assert(ddo.publicKey.length === 0)
        })

        it("should create an predefined ddo", async () => {

            const service: Partial<Service> & any = {
                serviceEndpoint: "http://",
                description: "nice service",
            }

            const ddo = new DDO({
                service: [service as any],
            })
            assert(ddo)

            assert(ddo.service.length === 1)
            assert((ddo.service[0] as any).description === service.description)

            assert(ddo.authentication.length === 0)
            assert(ddo.publicKey.length === 0)
        })
    })

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

        it("should properly deserialize from serialized object", async () => {

            const ddoString = DDO.serialize(testDDO)
            assert.typeOf(ddoString, "string")

            const ddo: DDO = DDO.deserialize(ddoString)
            assert.instanceOf(ddo, DDO)

            assert.equal(ddo.id, testDDO.id)
            assert.equal(ddo.publicKey[0].publicKeyPem, testDDO.publicKey[0].publicKeyPem)
        })

        it("should properly deserialize from json file", async () => {

            const ddo: DDO = DDO.deserialize(JSON.stringify(jsonDDO))
            assert(ddo)

            assert.equal(ddo.id, jsonDDO.id)
            assert.equal(ddo.publicKey[0].publicKeyPem, jsonDDO.publicKey[0].publicKeyPem)
        })
    })

    describe("#getChecksum()", () => {
        it("should properly generate a the checksum DDO", async () => {
            const ddo = new DDO(testDDO)
            const checksum = ddo.getChecksum()

            assert.equal(checksum, "0x15f27a7a3c7b15d2b06dec7347c6b8da168adddd7df51a8ebbbe87b59b80049b")
        })
    })

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

        const publicKey = `0x${"a".repeat(40)}`
        const signature = `0x${"a".repeat(130)}`

        it("should properly generate the proof", async () => {
            const signTextSpy = spy.on(ocean.utils.signature, "signText", () => signature)
            const ddo = new DDO(testDDO)
            const checksum = ddo.getChecksum()
            const proof = await ddo.generateProof(ocean, publicKey)

            assert.include(proof as any, {
                creator: publicKey,
                type: "DDOIntegritySignature",
                signatureValue: signature,
            })
            expect(signTextSpy).to.have.been.called.with(checksum, publicKey)
        })
    })

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

        const publicKey = `0x${"a".repeat(40)}`

        it("should properly add the proof on the DDO", async () => {
            const fakeProof = {
                creation: Date.now(),
                creator: "test",
                type: "test",
                signaturValue: "test",
            } as any
            const ddo = new DDO(testDDO)
            const generateProofSpy = spy.on(ddo, "generateProof", () => fakeProof)
            await ddo.addProof(web3, publicKey)

            assert.equal(ddo.proof, fakeProof)
            expect(generateProofSpy).to.have.been.called.with(publicKey)
        })
    })
})