import buildDrawCommands from "./buildDrawCommands.js";
import BoundingSphere from "../../Core/BoundingSphere.js";
import Check from "../../Core/Check.js";
import defaultValue from "../../Core/defaultValue.js";
import defined from "../../Core/defined.js";
import Matrix4 from "../../Core/Matrix4.js";
import CustomShaderPipelineStage from "./CustomShaderPipelineStage.js";
import LightingPipelineStage from "./LightingPipelineStage.js";
import ModelColorPipelineStage from "./ModelColorPipelineStage.js";
import ModelExperimentalPrimitive from "./ModelExperimentalPrimitive.js";
import ModelExperimentalNode from "./ModelExperimentalNode.js";
import ModelExperimentalUtility from "./ModelExperimentalUtility.js";
import ModelRenderResources from "./ModelRenderResources.js";
import NodeRenderResources from "./NodeRenderResources.js";
import PrimitiveRenderResources from "./PrimitiveRenderResources.js";

/**
 * An in memory representation of the scene graph for a {@link ModelExperimental}
 *
 * @param {Object} options An object containing the following options
 * @param {ModelExperimental} options.model The model this scene graph belongs to
 * @param {ModelComponents} options.modelComponents The model components describing the model
 *
 * @alias ModelExperimentalSceneGraph
 * @constructor
 *
 * @private
 */
export default function ModelExperimentalSceneGraph(options) {
  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
  //>>includeStart('debug', pragmas.debug);
  Check.typeOf.object("options.model", options.model);
  Check.typeOf.object("options.modelComponents", options.modelComponents);
  //>>includeEnd('debug');

  /**
   * A reference to the {@link ModelExperimental} that owns this scene graph.
   *
   * @type {ModelExperimental}
   * @readonly
   *
   * @private
   */
  this._model = options.model;

  /**
   * The model components that represent the contents of the 3D model file.
   *
   * @type {ModelComponents}
   * @readonly
   *
   * @private
   */
  this._modelComponents = options.modelComponents;

  /**
   * Pipeline stages to apply across the model.
   *
   * @type {Object[]}
   * @readonly
   *
   * @private
   */
  this._pipelineStages = [];

  /**
   * The runtime nodes that make up the scene graph
   *
   * @type {ModelExperimentalNode[]}
   * @readonly
   *
   * @private
   */
  this._runtimeNodes = [];

  /**
   * Once computed, the {@link DrawCommand}s that are used to render this
   * scene graph are stored here.
   *
   * @type {DrawCommand[]}
   * @readonly
   *
   * @private
   */
  this._drawCommands = [];

  /**
   * The bounding sphere containing all the primitives in the scene graph.
   *
   * @type {BoundingSphere}
   * @readonly
   *
   * @private
   */
  this._boundingSphere = undefined;

  /**
   * The array of bounding spheres of all the primitives in the scene graph.
   *
   * @type {BoundingSphere[]}
   * @readonly
   *
   * @private
   */
  this._boundingSpheres = [];

  initialize(this);
}

function initialize(sceneGraph) {
  var modelMatrix = Matrix4.clone(sceneGraph._model.modelMatrix);
  var scene = sceneGraph._modelComponents.scene;

  ModelExperimentalUtility.correctModelMatrix(
    modelMatrix,
    scene.upAxis,
    scene.forwardAxis
  );

  var rootNodes = sceneGraph._modelComponents.scene.nodes;
  for (var i = 0; i < rootNodes.length; i++) {
    var rootNode = sceneGraph._modelComponents.scene.nodes[i];
    var rootNodeModelMatrix = Matrix4.multiply(
      modelMatrix,
      ModelExperimentalUtility.getNodeTransform(rootNode),
      new Matrix4()
    );

    traverseSceneGraph(sceneGraph, rootNode, rootNodeModelMatrix);
  }
}

/**
 * Recursively traverse through the nodes in the scene graph, using depth-first
 * post-order traversal.
 *
 * @param {ModelSceneGraph} sceneGraph The scene graph
 * @param {ModelComponents.Node} node The current node
 * @param {Matrix4} modelMatrix The current computed model matrix for this node.
 *
 * @private
 */
function traverseSceneGraph(sceneGraph, node, modelMatrix) {
  // No processing needs to happen if node has no children and no mesh primitives.
  if (!defined(node.children) && !defined(node.primitives)) {
    return;
  }

  // Traverse through scene graph.
  var i;
  if (defined(node.children)) {
    for (i = 0; i < node.children.length; i++) {
      var childNode = node.children[i];
      var childNodeModelMatrix = Matrix4.multiply(
        modelMatrix,
        ModelExperimentalUtility.getNodeTransform(childNode),
        new Matrix4()
      );

      traverseSceneGraph(sceneGraph, childNode, childNodeModelMatrix);
    }
  }

  // Process node and mesh primitives.
  var runtimeNode = new ModelExperimentalNode({
    node: node,
    modelMatrix: modelMatrix,
  });

  if (defined(node.primitives)) {
    for (i = 0; i < node.primitives.length; i++) {
      runtimeNode.runtimePrimitives.push(
        new ModelExperimentalPrimitive({
          primitive: node.primitives[i],
          node: node,
          model: sceneGraph._model,
        })
      );
    }
  }

  sceneGraph._runtimeNodes.push(runtimeNode);
}

/**
 * Generates the draw commands for each primitive in the model.
 *
 * @param {FrameState} frameState The current frame state. This is needed to
 * allocate GPU resources as needed.
 *
 * @private
 */
ModelExperimentalSceneGraph.prototype.buildDrawCommands = function (
  frameState
) {
  var modelRenderResources = new ModelRenderResources(this._model);

  var modelPipelineStages = [];
  var model = this._model;
  if (defined(model.color)) {
    modelPipelineStages.push(ModelColorPipelineStage);
  }

  var i, j, k;
  for (i = 0; i < modelPipelineStages.length; i++) {
    var modelPipelineStage = modelPipelineStages[i];
    modelPipelineStage.process(modelRenderResources, model, frameState);
  }

  for (i = 0; i < this._runtimeNodes.length; i++) {
    var runtimeNode = this._runtimeNodes[i];

    var nodeRenderResources = new NodeRenderResources(
      modelRenderResources,
      runtimeNode
    );

    for (j = 0; j < runtimeNode.pipelineStages.length; j++) {
      var nodePipelineStage = runtimeNode.pipelineStages[j];

      nodePipelineStage.process(
        nodeRenderResources,
        runtimeNode.node,
        frameState
      );
    }

    for (j = 0; j < runtimeNode.runtimePrimitives.length; j++) {
      var runtimePrimitive = runtimeNode.runtimePrimitives[j];

      // The pipeline stage array is copied because we don't want dynamic stages to be added to the primitive's default stages.
      var primitivePipelineStages = runtimePrimitive.pipelineStages.slice();

      if (defined(model.customShader)) {
        // The custom shader stage needs to go before the lighting stage.
        var lightingStageIndex = primitivePipelineStages.indexOf(
          LightingPipelineStage
        );
        primitivePipelineStages.splice(
          lightingStageIndex,
          0,
          CustomShaderPipelineStage
        );
      }

      var primitiveRenderResources = new PrimitiveRenderResources(
        nodeRenderResources,
        runtimePrimitive
      );

      for (k = 0; k < primitivePipelineStages.length; k++) {
        var primitivePipelineStage = primitivePipelineStages[k];

        primitivePipelineStage.process(
          primitiveRenderResources,
          runtimePrimitive.primitive,
          frameState
        );
      }

      this._boundingSpheres.push(primitiveRenderResources.boundingSphere);

      var drawCommands = buildDrawCommands(
        primitiveRenderResources,
        frameState
      );
      this._drawCommands.push.apply(this._drawCommands, drawCommands);
    }
  }
  this._boundingSphere = BoundingSphere.fromBoundingSpheres(
    this._boundingSpheres
  );
};