import { describe } from "mocha";
import { expect } from "chai";
import {
  AccessStatus,
  ComponentStats,
  DriveObject,
  FileType,
} from "../src/trees/treeTypes";
import {
  calculateComponentStats,
  addComponentStats,
  createEmptyComponentStats,
} from "../src/trees/treeTools";
import { ResearchObjectComponentType } from "../src/ResearchObject";

describe("TreeTools", () => {
  describe("addComponentStats", () => {
    it("adds two empty objects", () => {
      const res = addComponentStats(
        createEmptyComponentStats(),
        createEmptyComponentStats()
      );
      expect(res.code.count).to.eq(0);
      expect(res.code.size).to.eq(0);
      expect(res.data.count).to.eq(0);
      expect(res.data.size).to.eq(0);
      // expect(res.link.count).to.eq(0);
      // expect(res.link.size).to.eq(0);
      expect(res.unknown.count).to.eq(0);
      expect(res.unknown.size).to.eq(0);
    });

    it("adds an empty object to a nonempty object", () => {
      const res = addComponentStats(
        {
          code: {
            count: 1,
            size: 1,
            dirs: 11,
          },
          data: {
            count: 2,
            size: 2,
            dirs: 21,
          },
          // link: { count: 3, size: 3, dirs: 31 },
          pdf: {
            count: 4,
            size: 4,
            dirs: 41,
          },
          unknown: { count: 5, size: 5, dirs: 51 },
        },
        createEmptyComponentStats()
      );
      expect(res.code.count).to.eq(1);
      expect(res.code.size).to.eq(1);
      expect(res.code.dirs).to.eq(11);
      expect(res.data.count).to.eq(2);
      expect(res.data.size).to.eq(2);
      expect(res.data.dirs).to.eq(21);
      // expect(res.link.count).to.eq(3);
      // expect(res.link.size).to.eq(3);
      // expect(res.link.dirs).to.eq(31);
      expect(res.pdf.count).to.eq(4);
      expect(res.pdf.size).to.eq(4);
      expect(res.pdf.dirs).to.eq(41);
      expect(res.unknown.count).to.eq(5);
      expect(res.unknown.size).to.eq(5);
      expect(res.unknown.dirs).to.eq(51);
    });
  });
  describe("calculateComponentStats", () => {
    it("calculates empty case correctly", () => {
      const emptyDrive: DriveObject = {
        name: "",
        lastModified: "",
        componentType: ResearchObjectComponentType.DATA_BUCKET,
        accessStatus: AccessStatus.PUBLIC,
        size: 0,
        metadata: {},
        cid: "",
        type: FileType.DIR,
      };
      const res = calculateComponentStats(emptyDrive);
      expect(res?.code).to.be.undefined;
      expect(res?.data).to.be.undefined;
      // expect(res?.link).to.be.undefined;
      expect(res?.unknown).to.be.undefined;
      //   expect(res?.video).to.be.undefined;
    });

    it("calculates simple case correctly", () => {
      const simpleDrive: DriveObject = {
        name: "",
        lastModified: "",
        componentType: ResearchObjectComponentType.DATA_BUCKET,
        accessStatus: AccessStatus.PUBLIC,
        size: 0,
        metadata: {},
        cid: "",
        type: FileType.DIR,
        contains: [
          {
            componentType: ResearchObjectComponentType.CODE,
            size: 1,
            cid: "1",
            accessStatus: AccessStatus.PUBLIC,
            name: "a",
            lastModified: "1",
            metadata: {},
            type: FileType.FILE,
          },
        ],
      };
      const res = calculateComponentStats(simpleDrive) as ComponentStats;
      expect(res).to.exist;
      expect(res.code).to.not.be.undefined;
      expect(res.code.size).to.eq(1);
      expect(res.code.count).to.eq(1);
      expect(res.data.size).to.eq(0);
      expect(res.data.count).to.eq(0);
      // expect(res.link.size).to.eq(0);
      // expect(res.link.count).to.eq(0);
      expect(res.unknown.size).to.eq(0);
      expect(res.unknown.count).to.eq(0);
    });

    it("calculates with every component present in data bucket correctly", () => {
      const simpleDrive: DriveObject = {
        name: "",
        lastModified: "",
        componentType: ResearchObjectComponentType.DATA_BUCKET,
        accessStatus: AccessStatus.PUBLIC,
        size: 0,
        metadata: {},
        cid: "",
        type: FileType.DIR,
        contains: [
          {
            componentType: ResearchObjectComponentType.CODE,
            size: 1,
            cid: "1",
            accessStatus: AccessStatus.PUBLIC,
            name: "a",
            lastModified: "1",
            metadata: {},
            type: FileType.FILE,
          },
          {
            componentType: ResearchObjectComponentType.DATA,
            size: 2,
            cid: "2",
            accessStatus: AccessStatus.PUBLIC,
            name: "b",
            lastModified: "1",
            metadata: {},
            type: FileType.FILE,
          },
          {
            componentType: ResearchObjectComponentType.UNKNOWN,
            size: 3,
            cid: "3",
            accessStatus: AccessStatus.PUBLIC,
            name: "c",
            lastModified: "1",
            metadata: {},
            type: FileType.FILE,
          },
          // {
          //   componentType: ResearchObjectComponentType.LINK,
          //   size: 0,
          //   cid: '4',
          //   accessStatus: AccessStatus.PUBLIC,
          //   name: 'd',
          //   lastModified: '1',
          //   metadata: {},
          //   type: FileType.FILE,
          // },
        ],
      };
      const res = calculateComponentStats(simpleDrive) as ComponentStats;
      expect(res).to.exist;

      expect(res.code.size).to.eq(1);
      expect(res.code.count).to.eq(1);

      expect(res.data.size).to.eq(2);
      expect(res.data.count).to.eq(1);

      expect(res.unknown.size).to.eq(3);
      expect(res.unknown.count).to.eq(1);

      // expect(res.link.size).to.eq(0);
      // expect(res.link.count).to.eq(1);
    });

    it("calculates nesting of single component type correctly", () => {
      const simpleDrive: DriveObject = {
        name: "",
        lastModified: "",
        componentType: ResearchObjectComponentType.DATA_BUCKET,
        accessStatus: AccessStatus.PUBLIC,
        size: 0,
        metadata: {},
        cid: "",
        type: FileType.DIR,
        contains: [
          {
            componentType: ResearchObjectComponentType.CODE,
            size: 20,
            cid: "1",
            accessStatus: AccessStatus.PUBLIC,
            name: "code",
            lastModified: "1",
            metadata: {},
            type: FileType.DIR,
            contains: [
              {
                componentType: ResearchObjectComponentType.CODE,
                size: 10,
                cid: "2",
                accessStatus: AccessStatus.PUBLIC,
                name: "code",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
              {
                componentType: ResearchObjectComponentType.CODE,
                size: 10,
                cid: "3",
                accessStatus: AccessStatus.PUBLIC,
                name: "code2",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
            ],
          },
        ],
      };
      const res = calculateComponentStats(simpleDrive) as ComponentStats;

      expect(res.code.size).to.eq(20);
      expect(res.code.count).to.eq(2);
      expect(res.code.dirs).to.eq(1);
    });

    it("calculates nesting of single component type and an additional component nested correctly", () => {
      const simpleDrive: DriveObject = {
        name: "",
        lastModified: "",
        componentType: ResearchObjectComponentType.DATA_BUCKET,
        accessStatus: AccessStatus.PUBLIC,
        size: 0,
        metadata: {},
        cid: "",
        type: FileType.DIR,
        contains: [
          {
            componentType: ResearchObjectComponentType.CODE,
            size: 30,
            cid: "1",
            accessStatus: AccessStatus.PUBLIC,
            name: "code",
            lastModified: "1",
            metadata: {},
            type: FileType.DIR,
            contains: [
              {
                componentType: ResearchObjectComponentType.CODE,
                size: 10,
                cid: "2",
                accessStatus: AccessStatus.PUBLIC,
                name: "code",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
              {
                componentType: ResearchObjectComponentType.CODE,
                size: 10,
                cid: "3",
                accessStatus: AccessStatus.PUBLIC,
                name: "code2",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
              {
                componentType: ResearchObjectComponentType.UNKNOWN,
                size: 10,
                cid: "4",
                accessStatus: AccessStatus.PUBLIC,
                name: "unknown",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
            ],
          },
        ],
      };
      const res = calculateComponentStats(simpleDrive) as ComponentStats;

      expect(res.code.size).to.eq(20);
      expect(res.code.count).to.eq(2);
      expect(res.code.dirs).to.eq(1);

      expect(res.unknown.size).to.eq(10);
      expect(res.unknown.count).to.eq(1);
      expect(res.unknown.dirs).to.eq(0);
    });

    it("calculates deep complex nesting of multiple component types", () => {
      const simpleDrive: DriveObject = {
        name: "",
        lastModified: "",
        componentType: ResearchObjectComponentType.DATA_BUCKET,
        accessStatus: AccessStatus.PUBLIC,
        size: 0,
        metadata: {},
        cid: "",
        type: FileType.DIR,
        contains: [
          {
            componentType: ResearchObjectComponentType.CODE,
            size: 30,
            cid: "1",
            accessStatus: AccessStatus.PUBLIC,
            name: "code",
            lastModified: "1",
            metadata: {},
            type: FileType.DIR,
            contains: [
              {
                componentType: ResearchObjectComponentType.CODE,
                size: 10,
                cid: "2",
                accessStatus: AccessStatus.PUBLIC,
                name: "code",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
              {
                componentType: ResearchObjectComponentType.CODE,
                size: 10,
                cid: "3",
                accessStatus: AccessStatus.PUBLIC,
                name: "code2",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
              {
                componentType: ResearchObjectComponentType.UNKNOWN,
                size: 10,
                cid: "4",
                accessStatus: AccessStatus.PUBLIC,
                name: "unknown",
                lastModified: "1",
                metadata: {},
                type: FileType.FILE,
              },
              {
                componentType: ResearchObjectComponentType.UNKNOWN,
                size: 10,
                cid: "5",
                accessStatus: AccessStatus.PUBLIC,
                name: "unknown-folder",
                lastModified: "1",
                metadata: {},
                type: FileType.DIR,
                contains: [
                  {
                    componentType: ResearchObjectComponentType.CODE,
                    size: 100,
                    cid: "3",
                    accessStatus: AccessStatus.PUBLIC,
                    name: "code3",
                    lastModified: "1",
                    metadata: {},
                    type: FileType.FILE,
                  },
                ],
              },
            ],
          },
        ],
      };
      const res = calculateComponentStats(simpleDrive) as ComponentStats;

      expect(res.code.size).to.eq(120);
      expect(res.code.count).to.eq(3);
      expect(res.code.dirs).to.eq(1);

      expect(res.unknown.size).to.eq(10);
      expect(res.unknown.count).to.eq(1);
      expect(res.unknown.dirs).to.eq(1);
    });
  });

  it("defers to cached component stats if available", () => {
    const simpleDrive: DriveObject = {
      name: "",
      lastModified: "",
      componentType: ResearchObjectComponentType.DATA_BUCKET,
      accessStatus: AccessStatus.PUBLIC,
      size: 0,
      metadata: {},
      cid: "",
      type: FileType.DIR,
      componentStats: {
        code: { count: 1337, size: 1337, dirs: 1337 },
        data: { count: 1337, size: 1337, dirs: 1337 },
        // link: { count: 1337, size: 1337, dirs: 1337 },
        pdf: { count: 1337, size: 1337, dirs: 1337 },
        unknown: { count: 1337, size: 1337, dirs: 1337 },
      },
      contains: [
        {
          componentType: ResearchObjectComponentType.CODE,
          size: 30,
          cid: "1",
          accessStatus: AccessStatus.PUBLIC,
          name: "code",
          lastModified: "1",
          metadata: {},
          type: FileType.DIR,

          contains: [
            {
              componentType: ResearchObjectComponentType.CODE,
              size: 10,
              cid: "2",
              accessStatus: AccessStatus.PUBLIC,
              name: "code",
              lastModified: "1",
              metadata: {},
              type: FileType.FILE,
            },
            {
              componentType: ResearchObjectComponentType.CODE,
              size: 10,
              cid: "3",
              accessStatus: AccessStatus.PUBLIC,
              name: "code2",
              lastModified: "1",
              metadata: {},
              type: FileType.FILE,
            },
            {
              componentType: ResearchObjectComponentType.UNKNOWN,
              size: 10,
              cid: "4",
              accessStatus: AccessStatus.PUBLIC,
              name: "unknown",
              lastModified: "1",
              metadata: {},
              type: FileType.FILE,
            },
            {
              componentType: ResearchObjectComponentType.UNKNOWN,
              size: 10,
              cid: "5",
              accessStatus: AccessStatus.PUBLIC,
              name: "unknown-folder",
              lastModified: "1",
              metadata: {},
              type: FileType.DIR,
              contains: [
                {
                  componentType: ResearchObjectComponentType.CODE,
                  size: 100,
                  cid: "3",
                  accessStatus: AccessStatus.PUBLIC,
                  name: "code3",
                  lastModified: "1",
                  metadata: {},
                  type: FileType.FILE,
                },
              ],
            },
          ],
        },
      ],
    };
    const res = calculateComponentStats(simpleDrive) as ComponentStats;

    expect(res.code.size).to.eq(1337);
    expect(res.code.count).to.eq(1337);
    expect(res.code.dirs).to.eq(1337);

    expect(res.unknown.size).to.eq(1337);
    expect(res.unknown.count).to.eq(1337);
    expect(res.unknown.dirs).to.eq(1337);
  });

  it("defers to nested cached component stats if available", () => {
    const simpleDrive: DriveObject = {
      name: "",
      lastModified: "",
      componentType: ResearchObjectComponentType.DATA_BUCKET,
      accessStatus: AccessStatus.PUBLIC,
      size: 0,
      metadata: {},
      cid: "",
      type: FileType.DIR,
      contains: [
        {
          componentType: ResearchObjectComponentType.CODE,
          size: 30,
          cid: "1",
          accessStatus: AccessStatus.PUBLIC,
          name: "code",
          lastModified: "1",
          metadata: {},
          type: FileType.DIR,
          contains: [
            {
              componentType: ResearchObjectComponentType.CODE,
              size: 10,
              cid: "2",
              accessStatus: AccessStatus.PUBLIC,
              name: "code",
              lastModified: "1",
              metadata: {},
              type: FileType.FILE,
            },
            {
              componentType: ResearchObjectComponentType.CODE,
              size: 10,
              cid: "3",
              accessStatus: AccessStatus.PUBLIC,
              name: "code2",
              lastModified: "1",
              metadata: {},
              type: FileType.FILE,
            },
            {
              componentType: ResearchObjectComponentType.UNKNOWN,
              size: 10,
              cid: "4",
              accessStatus: AccessStatus.PUBLIC,
              name: "unknown",
              lastModified: "1",
              metadata: {},
              type: FileType.FILE,
            },
            {
              componentType: ResearchObjectComponentType.UNKNOWN,
              size: 10,
              cid: "5",
              accessStatus: AccessStatus.PUBLIC,
              name: "unknown-folder",
              lastModified: "1",
              metadata: {},
              type: FileType.DIR,
              componentStats: {
                code: { count: 50, size: 50, dirs: 50 },
                data: { count: 0, size: 0, dirs: 0 },
                // link: { count: 0, size: 0, dirs: 0 },
                pdf: { count: 99, size: 99, dirs: 99 },
                unknown: { count: 0, size: 0, dirs: 0 },
              },
              contains: [
                {
                  componentType: ResearchObjectComponentType.CODE,
                  size: 100,
                  cid: "3",
                  accessStatus: AccessStatus.PUBLIC,
                  name: "code3",
                  lastModified: "1",
                  metadata: {},
                  type: FileType.FILE,
                },
              ],
            },
          ],
        },
      ],
    };
    const res = calculateComponentStats(simpleDrive) as ComponentStats;

    expect(res.code.size).to.eq(20 + 50);
    expect(res.code.count).to.eq(2 + 50);
    expect(res.code.dirs).to.eq(1 + 50);

    expect(res.unknown.size).to.eq(10);
    expect(res.unknown.count).to.eq(1);
    expect(res.unknown.dirs).to.eq(1);

    expect(res.pdf.size).to.eq(99);
    expect(res.pdf.count).to.eq(99);
    expect(res.pdf.dirs).to.eq(99);
  });
});