import {
  MetadataSchema,
  parseFeatureMetadataLegacy,
  PixelDatatype,
  PixelFormat,
  Texture,
} from "../../Source/Cesium.js";
import createContext from "../createContext.js";
import MetadataTester from "../MetadataTester.js";

describe(
  "Scene/parseFeatureMetadataLegacy",
  function () {
    var featureTablesSchema = {
      classes: {
        building: {
          properties: {
            name: {
              type: "STRING",
            },
            height: {
              type: "FLOAT64",
            },
          },
        },
        tree: {
          properties: {
            species: {
              type: "STRING",
            },
          },
        },
      },
    };

    var featureTexturesSchema = {
      classes: {
        map: {
          properties: {
            color: {
              type: "ARRAY",
              componentType: "UINT8",
              componentCount: 3,
            },
            intensity: {
              type: "UINT8",
            },
          },
        },
        ortho: {
          properties: {
            vegetation: {
              type: "UINT8",
              normalized: true,
            },
          },
        },
      },
    };

    it("throws without extension", function () {
      expect(function () {
        return parseFeatureMetadataLegacy({
          extension: undefined,
          schema: new MetadataSchema(featureTablesSchema),
        });
      }).toThrowDeveloperError();
    });

    it("throws without schema", function () {
      expect(function () {
        return parseFeatureMetadataLegacy({
          extension: {},
          schema: undefined,
        });
      }).toThrowDeveloperError();
    });

    it("parses extension with default values", function () {
      var metadata = parseFeatureMetadataLegacy({
        extension: {},
        schema: new MetadataSchema(featureTablesSchema),
      });

      expect(metadata.schema).toBeDefined();
      expect(metadata.statistics).toBeUndefined();
      expect(metadata.extras).toBeUndefined();
      expect(metadata.extensions).toBeUndefined();
    });

    it("parses extension with feature tables", function () {
      if (!MetadataTester.isSupported()) {
        return;
      }

      var featureTableResults = MetadataTester.createFeatureTables({
        schema: featureTablesSchema,
        featureTables: {
          buildings: {
            class: "building",
            properties: {
              name: ["Building A", "Building B", "Building C"],
              height: [10.0, 20.0, 30.0],
            },
          },
          trees: {
            class: "tree",
            properties: {
              species: ["Oak", "Pine"],
            },
          },
        },
      });

      var extension = {
        schema: featureTablesSchema,
        featureTables: featureTableResults.featureTables,
      };

      var metadata = parseFeatureMetadataLegacy({
        extension: extension,
        schema: new MetadataSchema(featureTablesSchema),
        bufferViews: featureTableResults.bufferViews,
      });

      var buildingClass = metadata.schema.classes.building;
      var treeClass = metadata.schema.classes.tree;

      expect(buildingClass.id).toBe("building");
      expect(treeClass.id).toBe("tree");

      var buildingsTable = metadata.getPropertyTable(0);
      var treesTable = metadata.getPropertyTable(1);

      expect(buildingsTable.id).toBe("buildings");
      expect(buildingsTable.name).not.toBeDefined();
      expect(buildingsTable.count).toBe(3);
      expect(buildingsTable.class).toBe(buildingClass);
      expect(buildingsTable.getPropertyIds().length).toBe(2);
      expect(buildingsTable.getProperty(0, "name")).toBe("Building A");
      expect(buildingsTable.getProperty(1, "name")).toBe("Building B");
      expect(buildingsTable.getProperty(2, "name")).toBe("Building C");
      expect(buildingsTable.getProperty(0, "height")).toBe(10.0);
      expect(buildingsTable.getProperty(1, "height")).toBe(20.0);
      expect(buildingsTable.getProperty(2, "height")).toBe(30.0);

      expect(treesTable.id).toBe("trees");
      expect(treesTable.name).not.toBeDefined();
      expect(treesTable.count).toBe(2);
      expect(treesTable.class).toBe(treeClass);
      expect(treesTable.getPropertyIds().length).toBe(1);
      expect(treesTable.getProperty(0, "species")).toBe("Oak");
      expect(treesTable.getProperty(1, "species")).toBe("Pine");
    });

    it("parses extension with feature textures", function () {
      var context = createContext();
      var texture0 = new Texture({
        context: context,
        pixelFormat: PixelFormat.RGBA,
        pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
        source: {
          arrayBufferView: new Uint8Array([1, 2, 3, 4]),
          width: 1,
          height: 1,
        },
      });
      var texture1 = new Texture({
        context: context,
        pixelFormat: PixelFormat.LUMINANCE,
        pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
        source: {
          arrayBufferView: new Uint8Array([5]),
          width: 1,
          height: 1,
        },
      });

      var textures = {
        0: texture0,
        1: texture1,
      };

      var extension = {
        schema: featureTexturesSchema,
        featureTextures: {
          mapTexture: {
            class: "map",
            properties: {
              color: {
                channels: "rgb",
                texture: {
                  index: 0,
                  texCoord: 0,
                },
              },
              intensity: {
                channels: "a",
                texture: {
                  index: 0,
                  texCoord: 0,
                },
              },
            },
          },
          orthoTexture: {
            class: "ortho",
            properties: {
              vegetation: {
                channels: "r",
                texture: {
                  index: 1,
                  texCoord: 1,
                },
              },
            },
          },
        },
      };

      var metadata = parseFeatureMetadataLegacy({
        extension: extension,
        schema: new MetadataSchema(featureTexturesSchema),
        textures: textures,
      });

      var mapClass = metadata.schema.classes.map;
      var orthoClass = metadata.schema.classes.ortho;

      expect(mapClass.id).toBe("map");
      expect(orthoClass.id).toBe("ortho");

      var mapTexture = metadata.getPropertyTexture(0);
      var orthoTexture = metadata.getPropertyTexture(1);

      expect(mapTexture.class).toBe(mapClass);
      expect(mapTexture.id).toBe("mapTexture");
      expect(mapTexture.name).not.toBeDefined();
      expect(orthoTexture.class).toBe(orthoClass);
      expect(orthoTexture.id).toBe("orthoTexture");
      expect(orthoTexture.name).not.toBeDefined();

      texture0.destroy();
      texture1.destroy();
      context.destroyForSpecs();
    });

    it("parses extension with statistics", function () {
      var statistics = {
        classes: {
          tree: {
            count: 100,
            properties: {
              height: {
                min: 10.0,
                max: 20.0,
              },
            },
          },
        },
      };
      var extension = {
        statistics: statistics,
      };
      var metadata = parseFeatureMetadataLegacy({
        extension: extension,
        schema: new MetadataSchema(featureTexturesSchema),
      });
      expect(metadata.statistics).toBe(statistics);
    });

    it("parses extension with extras", function () {
      var extras = {
        description: "Extra",
      };
      var extension = {
        extras: extras,
      };
      var metadata = parseFeatureMetadataLegacy({
        extension: extension,
        schema: new MetadataSchema(featureTexturesSchema),
      });
      expect(metadata.extras).toBe(extras);
    });

    it("parses extension with extensions", function () {
      var extensions = {
        EXT_other_extension: {},
      };
      var extension = {
        extensions: extensions,
      };
      var metadata = parseFeatureMetadataLegacy({
        extension: extension,
        schema: new MetadataSchema(featureTexturesSchema),
      });

      expect(metadata.extensions).toBe(extensions);
    });
  },
  "WebGL"
);