import { describe } from "mocha";
import { expect } from "chai";
import { RoCrateTransformer } from "../../src/transformers/RoCrateTransformer";
import ResearchObjectTi from "../../src/ResearchObject-ti";
import { RoCrate, RoCrateGraph } from "../../src/RoCrate";
import { createCheckers } from "ts-interface-checker";
import exampleNode from "../example-data/exampleNode.json";
import exampleRoCrate from "../example-data/exampleRoCrate.json";
import exampleNodeWithAuthors from "../example-data/exampleNodeWithAuthors.json";
import expectedJsonLd from "../example-data/exampleNodeToRoCrate.json";
import exampleRoCrateWithWorkflow from "../example-data/roCrateWithWorkflow.json";
import {
  CodeComponent,
  DataComponent,
  PdfComponent,
  ResearchObjectV1,
} from "../../src/ResearchObject";

import { CreativeWork } from "schema-dts";
const context = "https://www.researchobject.org/ro-crate/1.1/context.jsonld";
const checkers = createCheckers(ResearchObjectTi);

const transformer = new RoCrateTransformer();

describe("RoCrateTransformer", () => {
  it("Imports a simple valid RO-Crate object", () => {
    const roCrate = exampleRoCrate;

    const researchObject = transformer.importObject(roCrate);
    checkers.ResearchObjectV1.check(researchObject);
  });

  // skipping due to lossy conversion, need to update spec to capture encoding
  it("Exports a simple valid ResearchObject to RO-Crate format", async () => {
    const researchObject = exampleNode;

    const roCrate = transformer.exportObject(researchObject);
    // Validate the output as JSON-LD

    // res = await compact(roCrate["@graph"], roCrate["@context"]);
    expect(roCrate).to.deep.equal(expectedJsonLd);
  });

  it("Properly imports PDF components", () => {
    const roCrate = exampleRoCrate;

    const researchObject = transformer.importObject(
      roCrate
    ) as ResearchObjectV1;
    const pdfComponent = researchObject.components.find(
      (component) => component.type === "pdf"
    ) as PdfComponent;

    expect(pdfComponent).to.not.be.undefined;
    expect(pdfComponent.payload.url).to.equal(
      "https://example.com/example.pdf"
    );
  });

  it("Properly imports code components", () => {
    const roCrate = exampleRoCrateWithWorkflow;

    const researchObject = transformer.importObject(
      roCrate
    ) as ResearchObjectV1;

    const codeComponent = researchObject.components.find(
      (component) => component.type === "code"
    ) as CodeComponent;

    expect(codeComponent).to.not.be.undefined;
    expect(codeComponent.payload.url).to.equal(
      "http://example.com/workflows/alignment"
    );
  });

  it("Properly imports data components", () => {
    const roCrate = exampleRoCrate;

    const researchObject = transformer.importObject(
      roCrate
    ) as ResearchObjectV1;
    const dataComponent = researchObject.components.find(
      (component) => component.type === "data"
    ) as DataComponent;

    expect(dataComponent).to.not.be.undefined;
    expect(dataComponent.payload.cid).to.equal(
      "https://doi.org/10.5281/zenodo.1234567"
    );
  });

  it("Properly exports PDF components", () => {
    const researchObject = exampleNode;

    const roCrate = transformer.exportObject(researchObject) as RoCrate;
    const pdfComponent = roCrate["@graph"].find(
      (item: RoCrateGraph) =>
        typeof item !== "string" &&
        item["@type"] &&
        item["@type"] === "CreativeWork" &&
        (item as CreativeWork).encodingFormat === "application/pdf"
    ) as CreativeWork;

    expect(pdfComponent).to.not.be.undefined;
    expect(pdfComponent.url).to.equal(
      "https://ipfs.io/ipfs/bafybeic3ach4ibambafznjsa3p446ghds3hp7742fkisldroe4wt6q5bsy"
    );
    expect((pdfComponent as any)["/"]).to.equal(
      "bafybeic3ach4ibambafznjsa3p446ghds3hp7742fkisldroe4wt6q5bsy"
    );
  });

  it("Properly exports code components", () => {
    const researchObject = exampleNode;

    const roCrate = transformer.exportObject(researchObject);

    const codeComponent = roCrate["@graph"].find(
      (item: RoCrateGraph) =>
        typeof item !== "string" &&
        item["@type"] === "SoftwareSourceCode" &&
        item.encodingFormat === "text/plain"
    );

    expect(codeComponent).to.not.be.undefined;
    expect(codeComponent["/"]).to.equal(
      "bafybeibzxn2il4q7att4bf3lvrcc2peovcdokv3jsbzne5v6ad5tr6mi6i"
    );
    expect(codeComponent.url).to.equal(
      "https://ipfs.io/ipfs/bafybeibzxn2il4q7att4bf3lvrcc2peovcdokv3jsbzne5v6ad5tr6mi6i"
    );
  });

  it("Properly exports data components", () => {
    const researchObject = exampleNode;
    const roCrate = transformer.exportObject(researchObject);
    const dataComponent = roCrate["@graph"].find(
      (item: RoCrateGraph) =>
        typeof item !== "string" &&
        item["@type"] === "Dataset" &&
        item.encodingFormat === "application/octet-stream"
    );

    expect(dataComponent).to.not.be.undefined;
    expect(dataComponent.url).to.equal(
      "https://ipfs.io/ipfs/bafybeigzwjr6xkcdy4b7rrtzbbpwq3isx3zaesfopnpr3bqld3uddc5k3m"
    );
    expect(dataComponent["/"]).to.equal(
      "bafybeigzwjr6xkcdy4b7rrtzbbpwq3isx3zaesfopnpr3bqld3uddc5k3m"
    );
  });

  it("Properly exports authors", () => {
    const researchObject = exampleNodeWithAuthors;
    const roCrate = transformer.exportObject(researchObject);
    // console.log("RO", roCrate);
    const authors = roCrate["@graph"].filter(
      (item: RoCrateGraph) =>
        typeof item !== "string" && item["@type"] === "Person"
    );

    expect(authors).to.not.be.undefined;
    expect(authors.length).to.equal(17);
  });
  it("Properly handles CEDAR link", () => {
    const researchObject = exampleNodeWithAuthors;
    const roCrate = transformer.exportObject(researchObject);
    // console.log("RO", roCrate);
    const cedar = roCrate["@graph"].find(
      (item: RoCrateGraph) =>
        typeof item !== "string" &&
        item["@type"] === "Dataset" &&
        item["@id"] == "dd562a70-0bb9-4a07-8b00-c414bc8b9ad9" &&
        item["schemaVersion"] &&
        item["schemaVersion"].toString().length > 0
    );

    expect(cedar).to.not.be.undefined;
  });
  it("Adds orcid.org prefix to author ids", () => {
    const researchObject = exampleNodeWithAuthors;
    const roCrate = transformer.exportObject(researchObject);
    // console.log("RO", roCrate);
    console.log("EXPORTED RO-CRATE", JSON.stringify(roCrate));
    const authors = roCrate["@graph"].filter(
      (item: RoCrateGraph) =>
        typeof item !== "string" && item["@type"] === "Person"
    );

    expect(authors).to.not.be.undefined;
    expect(authors[0]["@id"]).to.equal(
      `https://orcid.org/${researchObject.authors[0].orcid}`
    );
  });
});