import addExtensionsUsed from "./addExtensionsUsed.js"
import addToArray from "./addToArray.js"
import findAccessorMinMax from "./findAccessorMinMax.js"
import ForEach from "./ForEach.js"
import getAccessorByteStride from "./getAccessorByteStride.js"
import numberOfComponentsForType from "./numberOfComponentsForType.js"
import moveTechniqueRenderStates from "./moveTechniqueRenderStates.js"
import moveTechniquesToExtension from "./moveTechniquesToExtension.js"
import removeUnusedElements from "./removeUnusedElements.js"
import updateAccessorComponentTypes from "./updateAccessorComponentTypes.js"
import Cartesian3 from "../../Core/Cartesian3.js"
import Cartesian4 from "../../Core/Cartesian4.js"
import clone from "../../Core/clone.js"
import ComponentDatatype from "../../Core/ComponentDatatype.js"
import defaultValue from "../../Core/defaultValue.js"
import defined from "../../Core/defined.js"
import Matrix4 from "../../Core/Matrix4.js"
import Quaternion from "../../Core/Quaternion.js"
import WebGLConstants from "../../Core/WebGLConstants.js"

var updateFunctions = {
    '0.8': glTF08to10,
    '1.0': glTF10to20,
    '2.0': undefined
};

/**
 * Update the glTF version to the latest version (2.0), or targetVersion if specified.
 * Applies changes made to the glTF spec between revisions so that the core library
 * only has to handle the latest version.
 *
 * @param {Object} gltf A javascript object containing a glTF asset.
 * @param {Object} [options] Options for updating the glTF.
 * @param {String} [options.targetVersion] The glTF will be upgraded until it hits the specified version.
 * @returns {Object} The updated glTF asset.
 *
 * @private
 */
function updateVersion(gltf, options) {
    options = defaultValue(options, defaultValue.EMPTY_OBJECT);
    var targetVersion = options.targetVersion;
    var version = gltf.version;

    gltf.asset = defaultValue(gltf.asset, {
        version: '1.0'
    });

    gltf.asset.version = defaultValue(gltf.asset.version, '1.0');
    version = defaultValue(version, gltf.asset.version).toString();

    // Invalid version
    if (!Object.prototype.hasOwnProperty.call(updateFunctions, version)) {
        // Try truncating trailing version numbers, could be a number as well if it is 0.8
        if (defined(version)) {
            version = version.substring(0, 3);
        }
        // Default to 1.0 if it cannot be determined
        if (!Object.prototype.hasOwnProperty.call(updateFunctions, version)) {
            version = '1.0';
        }
    }

    var updateFunction = updateFunctions[version];

    while (defined(updateFunction)) {
        if (version === targetVersion) {
            break;
        }
        updateFunction(gltf, options);
        version = gltf.asset.version;
        updateFunction = updateFunctions[version];
    }
    return gltf;
}

function updateInstanceTechniques(gltf) {
    var materials = gltf.materials;
    for (var materialId in materials) {
        if (Object.prototype.hasOwnProperty.call(materials, materialId)) {
            var material = materials[materialId];
            var instanceTechnique = material.instanceTechnique;
            if (defined(instanceTechnique)) {
                material.technique = instanceTechnique.technique;
                material.values = instanceTechnique.values;
                delete material.instanceTechnique;
            }
        }
    }
}

function setPrimitiveModes(gltf) {
    var meshes = gltf.meshes;
    for (var meshId in meshes) {
        if (Object.prototype.hasOwnProperty.call(meshes, meshId)) {
            var mesh = meshes[meshId];
            var primitives = mesh.primitives;
            if (defined(primitives)) {
                var primitivesLength = primitives.length;
                for (var i = 0; i < primitivesLength; ++i) {
                    var primitive = primitives[i];
                    var defaultMode = defaultValue(primitive.primitive, WebGLConstants.TRIANGLES);
                    primitive.mode = defaultValue(primitive.mode, defaultMode);
                    delete primitive.primitive;
                }
            }
        }
    }
}

function updateNodes(gltf) {
    var nodes = gltf.nodes;
    var axis = new Cartesian3();
    var quat = new Quaternion();
    for (var nodeId in nodes) {
        if (Object.prototype.hasOwnProperty.call(nodes, nodeId)) {
            var node = nodes[nodeId];
            if (defined(node.rotation)) {
                var rotation = node.rotation;
                Cartesian3.fromArray(rotation, 0, axis);
                Quaternion.fromAxisAngle(axis, rotation[3], quat);
                node.rotation = [quat.x, quat.y, quat.z, quat.w];
            }
            var instanceSkin = node.instanceSkin;
            if (defined(instanceSkin)) {
                node.skeletons = instanceSkin.skeletons;
                node.skin = instanceSkin.skin;
                node.meshes = instanceSkin.meshes;
                delete node.instanceSkin;
            }
        }
    }
}

function updateAnimations(gltf) {
    var animations = gltf.animations;
    var accessors = gltf.accessors;
    var bufferViews = gltf.bufferViews;
    var buffers = gltf.buffers;
    var updatedAccessors = {};
    var axis = new Cartesian3();
    var quat = new Quaternion();
    for (var animationId in animations) {
        if (Object.prototype.hasOwnProperty.call(animations, animationId)) {
            var animation = animations[animationId];
            var channels = animation.channels;
            var parameters = animation.parameters;
            var samplers = animation.samplers;
            if (defined(channels)) {
                var channelsLength = channels.length;
                for (var i = 0; i < channelsLength; ++i) {
                    var channel = channels[i];
                    if (channel.target.path === 'rotation') {
                        var accessorId = parameters[samplers[channel.sampler].output];
                        if (defined(updatedAccessors[accessorId])) {
                            continue;
                        }
                        updatedAccessors[accessorId] = true;
                        var accessor = accessors[accessorId];
                        var bufferView = bufferViews[accessor.bufferView];
                        var buffer = buffers[bufferView.buffer];
                        var source = buffer.extras._pipeline.source;
                        var byteOffset = source.byteOffset + bufferView.byteOffset + accessor.byteOffset;
                        var componentType = accessor.componentType;
                        var count = accessor.count;
                        var componentsLength = numberOfComponentsForType(accessor.type);
                        var length = accessor.count * componentsLength;
                        var typedArray = ComponentDatatype.createArrayBufferView(componentType, source.buffer, byteOffset, length);

                        for (var j = 0; j < count; j++) {
                            var offset = j * componentsLength;
                            Cartesian3.unpack(typedArray, offset, axis);
                            var angle = typedArray[offset + 3];
                            Quaternion.fromAxisAngle(axis, angle, quat);
                            Quaternion.pack(quat, typedArray, offset);
                        }
                    }
                }
            }
        }
    }
}

function removeTechniquePasses(gltf) {
    var techniques = gltf.techniques;
    for (var techniqueId in techniques) {
        if (Object.prototype.hasOwnProperty.call(techniques, techniqueId)) {
            var technique = techniques[techniqueId];
            var passes = technique.passes;
            if (defined(passes)) {
                var passName = defaultValue(technique.pass, 'defaultPass');
                if (Object.prototype.hasOwnProperty.call(passes, passName)) {
                    var pass = passes[passName];
                    var instanceProgram = pass.instanceProgram;
                    technique.attributes = defaultValue(technique.attributes, instanceProgram.attributes);
                    technique.program = defaultValue(technique.program, instanceProgram.program);
                    technique.uniforms = defaultValue(technique.uniforms, instanceProgram.uniforms);
                    technique.states = defaultValue(technique.states, pass.states);
                }
                delete technique.passes;
                delete technique.pass;
            }
        }
    }
}

function glTF08to10(gltf) {
    if (!defined(gltf.asset)) {
        gltf.asset = {};
    }
    var asset = gltf.asset;
    asset.version = '1.0';
    // Profile should be an object, not a string
    if (typeof asset.profile === 'string') {
        var split = asset.profile.split(' ');
        asset.profile = {
            api: split[0],
            version: split[1]
        };
    } else {
        asset.profile = {};
    }

    // Version property should be in asset, not on the root element
    if (defined(gltf.version)) {
        delete gltf.version;
    }
    // material.instanceTechnique properties should be directly on the material
    updateInstanceTechniques(gltf);
    // primitive.primitive should be primitive.mode
    setPrimitiveModes(gltf);
    // Node rotation should be quaternion, not axis-angle
    // node.instanceSkin is deprecated
    updateNodes(gltf);
    // Animations that target rotations should be quaternion, not axis-angle
    updateAnimations(gltf);
    // technique.pass and techniques.passes are deprecated
    removeTechniquePasses(gltf);
    // gltf.allExtensions -> extensionsUsed
    if (defined(gltf.allExtensions)) {
        gltf.extensionsUsed = gltf.allExtensions;
        delete gltf.allExtensions;
    }
    // gltf.lights -> khrMaterialsCommon.lights
    if (defined(gltf.lights)) {
        var extensions = defaultValue(gltf.extensions, {});
        gltf.extensions = extensions;
        var materialsCommon = defaultValue(extensions.KHR_materials_common, {});
        extensions.KHR_materials_common = materialsCommon;
        materialsCommon.lights = gltf.lights;
        delete gltf.lights;
        addExtensionsUsed(gltf, 'KHR_materials_common');
    }
}

function removeAnimationSamplersIndirection(gltf) {
    var animations = gltf.animations;
    for (var animationId in animations) {
        if (Object.prototype.hasOwnProperty.call(animations, animationId)) {
            var animation = animations[animationId];
            var parameters = animation.parameters;
            if (defined(parameters)) {
                var samplers = animation.samplers;
                for (var samplerId in samplers) {
                    if (Object.prototype.hasOwnProperty.call(samplers, samplerId)) {
                        var sampler = samplers[samplerId];
                        sampler.input = parameters[sampler.input];
                        sampler.output = parameters[sampler.output];
                    }
                }
                delete animation.parameters;
            }
        }
    }
}

function objectToArray(object, mapping) {
    var array = [];
    for (var id in object) {
        if (Object.prototype.hasOwnProperty.call(object, id)) {
            var value = object[id];
            mapping[id] = array.length;
            array.push(value);
            if (!defined(value.name)) {
                value.name = id;
            }
        }
    }
    return array;
}

function objectsToArrays(gltf) {
    var i;
    var globalMapping = {
        accessors: {},
        animations: {},
        buffers: {},
        bufferViews: {},
        cameras: {},
        images: {},
        materials: {},
        meshes: {},
        nodes: {},
        programs: {},
        samplers: {},
        scenes: {},
        shaders: {},
        skins: {},
        textures: {},
        techniques: {}
    };

    // Map joint names to id names
    var jointName;
    var jointNameToId = {};
    var nodes = gltf.nodes;
    for (var id in nodes) {
        if (Object.prototype.hasOwnProperty.call(nodes, id)) {
            jointName = nodes[id].jointName;
            if (defined(jointName)) {
                jointNameToId[jointName] = id;
            }
        }
    }

    // Convert top level objects to arrays
    for (var topLevelId in gltf) {
        if (Object.prototype.hasOwnProperty.call(gltf, topLevelId) && defined(globalMapping[topLevelId])) {
            var objectMapping = {};
            var object = gltf[topLevelId];
            gltf[topLevelId] = objectToArray(object, objectMapping);
            globalMapping[topLevelId] = objectMapping;
        }
    }

    // Remap joint names to array indexes
    for (jointName in jointNameToId) {
        if (Object.prototype.hasOwnProperty.call(jointNameToId, jointName)) {
            jointNameToId[jointName] = globalMapping.nodes[jointNameToId[jointName]];
        }
    }

    // Fix references
    if (defined(gltf.scene)) {
        gltf.scene = globalMapping.scenes[gltf.scene];
    }
    ForEach.bufferView(gltf, function(bufferView) {
        if (defined(bufferView.buffer)) {
            bufferView.buffer = globalMapping.buffers[bufferView.buffer];
        }
    });
    ForEach.accessor(gltf, function(accessor) {
        if (defined(accessor.bufferView)) {
            accessor.bufferView = globalMapping.bufferViews[accessor.bufferView];
        }
    });
    ForEach.shader(gltf, function(shader) {
        var extensions = shader.extensions;
        if (defined(extensions)) {
            var binaryGltf = extensions.KHR_binary_glTF;
            if (defined(binaryGltf)) {
                shader.bufferView = globalMapping.bufferViews[binaryGltf.bufferView];
                delete extensions.KHR_binary_glTF;
            }
            if (Object.keys(extensions).length === 0) {
                delete shader.extensions;
            }
        }
    });
    ForEach.program(gltf, function(program) {
        if (defined(program.vertexShader)) {
            program.vertexShader = globalMapping.shaders[program.vertexShader];
        }
        if (defined(program.fragmentShader)) {
            program.fragmentShader = globalMapping.shaders[program.fragmentShader];
        }
    });
    ForEach.technique(gltf, function(technique) {
        if (defined(technique.program)) {
            technique.program = globalMapping.programs[technique.program];
        }
        ForEach.techniqueParameter(technique, function(parameter) {
            if (defined(parameter.node)) {
                parameter.node = globalMapping.nodes[parameter.node];
            }
            var value = parameter.value;
            if (typeof value === 'string') {
                parameter.value = {
                    index: globalMapping.textures[value]
                };
            }
        });
    });
    ForEach.mesh(gltf, function(mesh) {
        ForEach.meshPrimitive(mesh, function(primitive) {
            if (defined(primitive.indices)) {
                primitive.indices = globalMapping.accessors[primitive.indices];
            }
            ForEach.meshPrimitiveAttribute(primitive, function(accessorId, semantic) {
                primitive.attributes[semantic] = globalMapping.accessors[accessorId];
            });
            if (defined(primitive.material)) {
                primitive.material = globalMapping.materials[primitive.material];
            }
        });
    });
    ForEach.node(gltf, function(node) {
        var children = node.children;
        if (defined(children)) {
            var childrenLength = children.length;
            for (i = 0; i < childrenLength; ++i) {
                children[i] = globalMapping.nodes[children[i]];
            }
        }
        if (defined(node.meshes)) {
            // Split out meshes on nodes
            var meshes = node.meshes;
            var meshesLength = meshes.length;
            if (meshesLength > 0) {
                node.mesh = globalMapping.meshes[meshes[0]];
                for (i = 1; i < meshesLength; ++i) {
                    var meshNode = {
                        mesh: globalMapping.meshes[meshes[i]]
                    };
                    var meshNodeId = addToArray(gltf.nodes, meshNode);
                    if (!defined(children)) {
                        children = [];
                        node.children = children;
                    }
                    children.push(meshNodeId);
                }
            }
            delete node.meshes;
        }
        if (defined(node.camera)) {
            node.camera = globalMapping.cameras[node.camera];
        }
        if (defined(node.skin)) {
            node.skin = globalMapping.skins[node.skin];
        }
        if (defined(node.skeletons)) {
            // Assign skeletons to skins
            var skeletons = node.skeletons;
            var skeletonsLength = skeletons.length;
            if ((skeletonsLength > 0) && defined(node.skin)) {
                var skin = gltf.skins[node.skin];
                skin.skeleton = globalMapping.nodes[skeletons[0]];
            }
            delete node.skeletons;
        }
        if (defined(node.jointName)) {
            delete node.jointName;
        }
    });
    ForEach.skin(gltf, function(skin) {
        if (defined(skin.inverseBindMatrices)) {
            skin.inverseBindMatrices = globalMapping.accessors[skin.inverseBindMatrices];
        }
        var jointNames = skin.jointNames;
        if (defined(jointNames)) {
            var joints = [];
            var jointNamesLength = jointNames.length;
            for (i = 0; i < jointNamesLength; ++i) {
                joints[i] = jointNameToId[jointNames[i]];
            }
            skin.joints = joints;
            delete skin.jointNames;
        }
    });
    ForEach.scene(gltf, function(scene) {
        var sceneNodes = scene.nodes;
        if (defined(sceneNodes)) {
            var sceneNodesLength = sceneNodes.length;
            for (i = 0; i < sceneNodesLength; ++i) {
                sceneNodes[i] = globalMapping.nodes[sceneNodes[i]];
            }
        }
    });
    ForEach.animation(gltf, function(animation) {
        var samplerMapping = {};
        animation.samplers = objectToArray(animation.samplers, samplerMapping);
        ForEach.animationSampler(animation, function(sampler) {
            sampler.input = globalMapping.accessors[sampler.input];
            sampler.output = globalMapping.accessors[sampler.output];
        });
        ForEach.animationChannel(animation, function(channel) {
            channel.sampler = samplerMapping[channel.sampler];
            var target = channel.target;
            if (defined(target)) {
                target.node = globalMapping.nodes[target.id];
                delete target.id;
            }
        });
    });
    ForEach.material(gltf, function(material) {
        if (defined(material.technique)) {
            material.technique = globalMapping.techniques[material.technique];
        }
        ForEach.materialValue(material, function(value, name) {
            if (typeof value === 'string') {
                material.values[name] = {
                    index: globalMapping.textures[value]
                };
            }
        });
        var extensions = material.extensions;
        if (defined(extensions)) {
            var materialsCommon = extensions.KHR_materials_common;
            if (defined(materialsCommon)) {
                ForEach.materialValue(materialsCommon, function(value, name) {
                    if (typeof value === 'string') {
                        materialsCommon.values[name] = {
                            index: globalMapping.textures[value]
                        };
                    }
                });
            }
        }
    });
    ForEach.image(gltf, function(image) {
        var extensions = image.extensions;
        if (defined(extensions)) {
            var binaryGltf = extensions.KHR_binary_glTF;
            if (defined(binaryGltf)) {
                image.bufferView = globalMapping.bufferViews[binaryGltf.bufferView];
                image.mimeType = binaryGltf.mimeType;
                delete extensions.KHR_binary_glTF;
            }
            if (Object.keys(extensions).length === 0) {
                delete image.extensions;
            }
        }
    });
    ForEach.texture(gltf, function(texture) {
        if (defined(texture.sampler)) {
            texture.sampler = globalMapping.samplers[texture.sampler];
        }
        if (defined(texture.source)) {
            texture.source = globalMapping.images[texture.source];
        }
    });
}

function removeAnimationSamplerNames(gltf) {
    ForEach.animation(gltf, function(animation) {
        ForEach.animationSampler(animation, function(sampler) {
            delete sampler.name;
        });
    });
}

function removeEmptyArrays(gltf) {
    for (var topLevelId in gltf) {
        if (Object.prototype.hasOwnProperty.call(gltf, topLevelId)) {
            var array = gltf[topLevelId];
            if (Array.isArray(array) && array.length === 0) {
                delete gltf[topLevelId];
            }
        }
    }
    ForEach.node(gltf, function(node) {
        if (defined(node.children) && node.children.length === 0) {
            delete node.children;
        }
    });
}

function stripAsset(gltf) {
    var asset = gltf.asset;
    delete asset.profile;
    delete asset.premultipliedAlpha;
}

var knownExtensions = {
    CESIUM_RTC: true,
    KHR_materials_common: true,
    WEB3D_quantized_attributes: true
};
function requireKnownExtensions(gltf) {
    var extensionsUsed = gltf.extensionsUsed;
    gltf.extensionsRequired = defaultValue(gltf.extensionsRequired, []);
    if (defined(extensionsUsed)) {
        var extensionsUsedLength = extensionsUsed.length;
        for (var i = 0; i < extensionsUsedLength; ++i) {
            var extension = extensionsUsed[i];
            if (defined(knownExtensions[extension])) {
                gltf.extensionsRequired.push(extension);
            }
        }
    }
}

function removeBufferType(gltf) {
    ForEach.buffer(gltf, function(buffer) {
        delete buffer.type;
    });
}

function removeTextureProperties(gltf) {
    ForEach.texture(gltf, function(texture) {
        delete texture.format;
        delete texture.internalFormat;
        delete texture.target;
        delete texture.type;
    });
}

function requireAttributeSetIndex(gltf) {
    ForEach.mesh(gltf, function(mesh) {
        ForEach.meshPrimitive(mesh, function(primitive) {
            ForEach.meshPrimitiveAttribute(primitive, function(accessorId, semantic) {
                if (semantic === 'TEXCOORD') {
                    primitive.attributes.TEXCOORD_0 = accessorId;
                } else if (semantic === 'COLOR') {
                    primitive.attributes.COLOR_0 = accessorId;
                }
            });
            delete primitive.attributes.TEXCOORD;
            delete primitive.attributes.COLOR;
        });
    });
    ForEach.technique(gltf, function(technique) {
        ForEach.techniqueParameter(technique, function(parameter) {
            var semantic = parameter.semantic;
            if (defined(semantic)) {
                if (semantic === 'TEXCOORD') {
                    parameter.semantic = 'TEXCOORD_0';
                } else if (semantic === 'COLOR') {
                    parameter.semantic = 'COLOR_0';
                }
            }
        });
    });
}

var knownSemantics = {
    POSITION: true,
    NORMAL: true,
    TANGENT: true
};
var indexedSemantics = {
    COLOR: 'COLOR',
    JOINT : 'JOINTS',
    JOINTS: 'JOINTS',
    TEXCOORD: 'TEXCOORD',
    WEIGHT: 'WEIGHTS',
    WEIGHTS: 'WEIGHTS'
};
function underscoreApplicationSpecificSemantics(gltf) {
    var mappedSemantics = {};
    ForEach.mesh(gltf, function(mesh) {
        ForEach.meshPrimitive(mesh, function(primitive) {
            /*eslint-disable no-unused-vars*/
            ForEach.meshPrimitiveAttribute(primitive, function(accessorId, semantic) {
                if (semantic.charAt(0) !== '_') {
                    var setIndex = semantic.search(/_[0-9]+/g);
                    var strippedSemantic = semantic;
                    var suffix = '_0';
                    if (setIndex >= 0) {
                        strippedSemantic = semantic.substring(0, setIndex);
                        suffix = semantic.substring(setIndex);
                    }
                    var newSemantic;
                    var indexedSemantic = indexedSemantics[strippedSemantic];
                    if (defined(indexedSemantic)) {
                        newSemantic = indexedSemantic + suffix;
                        mappedSemantics[semantic] = newSemantic;
                    } else if (!defined(knownSemantics[strippedSemantic])) {
                        newSemantic = '_' + semantic;
                        mappedSemantics[semantic] = newSemantic;
                    }
                }
            });
            for (var semantic in mappedSemantics) {
                if (Object.prototype.hasOwnProperty.call(mappedSemantics, semantic)) {
                    var mappedSemantic = mappedSemantics[semantic];
                    var accessorId = primitive.attributes[semantic];
                    if (defined(accessorId)) {
                        delete primitive.attributes[semantic];
                        primitive.attributes[mappedSemantic] = accessorId;
                    }
                }
            }
        });
    });
    ForEach.technique(gltf, function(technique) {
        ForEach.techniqueParameter(technique, function(parameter) {
            var mappedSemantic = mappedSemantics[parameter.semantic];
            if (defined(mappedSemantic)) {
                parameter.semantic = mappedSemantic;
            }
        });
    });
}

function clampCameraParameters(gltf) {
    ForEach.camera(gltf, function(camera) {
        var perspective = camera.perspective;
        if (defined(perspective)) {
            var aspectRatio = perspective.aspectRatio;
            if (defined(aspectRatio) && aspectRatio === 0.0) {
                delete perspective.aspectRatio;
            }
            var yfov = perspective.yfov;
            if (defined(yfov) && yfov === 0.0) {
                perspective.yfov = 1.0;
            }
        }
    });
}

function computeAccessorByteStride(gltf, accessor) {
    return (defined(accessor.byteStride) && accessor.byteStride !== 0) ? accessor.byteStride : getAccessorByteStride(gltf, accessor);
}

function requireByteLength(gltf) {
    ForEach.buffer(gltf, function(buffer) {
        if (!defined(buffer.byteLength)) {
            buffer.byteLength = buffer.extras._pipeline.source.length;
        }
    });
    ForEach.accessor(gltf, function(accessor) {
        var bufferViewId = accessor.bufferView;
        if (defined(bufferViewId)) {
            var bufferView = gltf.bufferViews[bufferViewId];
            var accessorByteStride = computeAccessorByteStride(gltf, accessor);
            var accessorByteEnd = accessor.byteOffset + accessor.count * accessorByteStride;
            bufferView.byteLength = Math.max(defaultValue(bufferView.byteLength, 0), accessorByteEnd);
        }
    });
}

function moveByteStrideToBufferView(gltf) {
    var i;
    var j;
    var bufferView;
    var bufferViews = gltf.bufferViews;

    var bufferViewHasVertexAttributes = {};
    ForEach.accessorContainingVertexAttributeData(gltf, function(accessorId) {
        var accessor = gltf.accessors[accessorId];
        if (defined(accessor.bufferView)) {
            bufferViewHasVertexAttributes[accessor.bufferView] = true;
        }
    });

    // Map buffer views to a list of accessors
    var bufferViewMap = {};
    ForEach.accessor(gltf, function(accessor) {
        if (defined(accessor.bufferView)) {
            bufferViewMap[accessor.bufferView] = defaultValue(bufferViewMap[accessor.bufferView], []);
            bufferViewMap[accessor.bufferView].push(accessor);
        }
    });

    // Split accessors with different byte strides
    for (var bufferViewId in bufferViewMap) {
        if (Object.prototype.hasOwnProperty.call(bufferViewMap, bufferViewId)) {
            bufferView = bufferViews[bufferViewId];
            var accessors = bufferViewMap[bufferViewId];
            accessors.sort(function(a, b) {
                return a.byteOffset - b.byteOffset;
            });
            var currentByteOffset = 0;
            var currentIndex = 0;
            var accessorsLength = accessors.length;
            for (i = 0; i < accessorsLength; ++i) {
                var accessor = accessors[i];
                var accessorByteStride = computeAccessorByteStride(gltf, accessor);
                var accessorByteOffset = accessor.byteOffset;
                var accessorByteLength = accessor.count * accessorByteStride;
                delete accessor.byteStride;

                var hasNextAccessor = (i < accessorsLength - 1);
                var nextAccessorByteStride = hasNextAccessor ? computeAccessorByteStride(gltf, accessors[i + 1]) : undefined;
                if (accessorByteStride !== nextAccessorByteStride) {
                    var newBufferView = clone(bufferView, true);
                    if (bufferViewHasVertexAttributes[bufferViewId]) {
                        newBufferView.byteStride = accessorByteStride;
                    }
                    newBufferView.byteOffset += currentByteOffset;
                    newBufferView.byteLength = accessorByteOffset + accessorByteLength - currentByteOffset;
                    var newBufferViewId = addToArray(bufferViews, newBufferView);
                    for (j = currentIndex; j <= i; ++j) {
                        accessor = accessors[j];
                        accessor.bufferView = newBufferViewId;
                        accessor.byteOffset = accessor.byteOffset - currentByteOffset;
                    }
                    // Set current byte offset to next accessor's byte offset
                    currentByteOffset = hasNextAccessor ? accessors[i + 1].byteOffset : undefined;
                    currentIndex = i + 1;
                }
            }
        }
    }

    // Remove unused buffer views
    removeUnusedElements(gltf, ['accessor', 'bufferView', 'buffer']);
}

function requirePositionAccessorMinMax(gltf) {
    ForEach.accessorWithSemantic(gltf, 'POSITION', function(accessorId) {
        var accessor = gltf.accessors[accessorId];
        if (!defined(accessor.min) || !defined(accessor.max)) {
            var minMax = findAccessorMinMax(gltf, accessor);
            accessor.min = minMax.min;
            accessor.max = minMax.max;
        }
    });
}

function isNodeEmpty(node) {
    return (!defined(node.children) || node.children.length === 0) &&
        (!defined(node.meshes) || node.meshes.length === 0) &&
        !defined(node.camera) && !defined(node.skin) && !defined(node.skeletons) && !defined(node.jointName) &&
        (!defined(node.translation) || Cartesian3.fromArray(node.translation).equals(Cartesian3.ZERO)) &&
        (!defined(node.scale) || Cartesian3.fromArray(node.scale).equals(new Cartesian3(1.0, 1.0, 1.0))) &&
        (!defined(node.rotation) || Cartesian4.fromArray(node.rotation).equals(new Cartesian4(0.0, 0.0, 0.0, 1.0))) &&
        (!defined(node.matrix) || Matrix4.fromColumnMajorArray(node.matrix).equals(Matrix4.IDENTITY)) &&
        !defined(node.extensions) && !defined(node.extras);
}

function deleteNode(gltf, nodeId) {
    // Remove from list of nodes in scene
    ForEach.scene(gltf, function(scene) {
        var sceneNodes = scene.nodes;
        if (defined(sceneNodes)) {
            var sceneNodesLength = sceneNodes.length;
            for (var i = sceneNodesLength; i >= 0; --i) {
                if (sceneNodes[i] === nodeId) {
                    sceneNodes.splice(i, 1);
                    return;
                }
            }
        }
    });

    // Remove parent node's reference to this node, and delete the parent if also empty
    ForEach.node(gltf, function(parentNode, parentNodeId) {
        if (defined(parentNode.children)) {
            var index = parentNode.children.indexOf(nodeId);
            if (index > -1) {
                parentNode.children.splice(index, 1);

                if (isNodeEmpty(parentNode)) {
                    deleteNode(gltf, parentNodeId);
                }
            }
        }
    });

    delete gltf.nodes[nodeId];
}

function removeEmptyNodes(gltf) {
    ForEach.node(gltf, function(node, nodeId) {
        if (isNodeEmpty(node)) {
            deleteNode(gltf, nodeId);
        }
    });

    return gltf;
}

function requireAnimationAccessorMinMax(gltf) {
    ForEach.animation(gltf, function(animation) {
        ForEach.animationSampler(animation, function(sampler) {
            var accessor = gltf.accessors[sampler.input];
            if (!defined(accessor.min) || !defined(accessor.max)) {
                var minMax = findAccessorMinMax(gltf, accessor);
                accessor.min = minMax.min;
                accessor.max = minMax.max;
            }
        });
    });
}

function glTF10to20(gltf) {
    gltf.asset = defaultValue(gltf.asset, {});
    gltf.asset.version = '2.0';
    // material.instanceTechnique properties should be directly on the material. instanceTechnique is a gltf 0.8 property but is seen in some 1.0 models.
    updateInstanceTechniques(gltf);
    // animation.samplers now refers directly to accessors and animation.parameters should be removed
    removeAnimationSamplersIndirection(gltf);
    // Remove empty nodes and re-assign referencing indices
    removeEmptyNodes(gltf);
    // Top-level objects are now arrays referenced by index instead of id
    objectsToArrays(gltf);
    // Animation.sampler objects cannot have names
    removeAnimationSamplerNames(gltf);
    // asset.profile no longer exists
    stripAsset(gltf);
    // Move known extensions from extensionsUsed to extensionsRequired
    requireKnownExtensions(gltf);
    // bufferView.byteLength and buffer.byteLength are required
    requireByteLength(gltf);
    // byteStride moved from accessor to bufferView
    moveByteStrideToBufferView(gltf);
    // accessor.min and accessor.max must be defined for accessors containing POSITION attributes
    requirePositionAccessorMinMax(gltf);
    // An animation sampler's input accessor must have min and max properties defined
    requireAnimationAccessorMinMax(gltf);
    // buffer.type is unnecessary and should be removed
    removeBufferType(gltf);
    // Remove format, internalFormat, target, and type
    removeTextureProperties(gltf);
    // TEXCOORD and COLOR attributes must be written with a set index (TEXCOORD_#)
    requireAttributeSetIndex(gltf);
    // Add underscores to application-specific parameters
    underscoreApplicationSpecificSemantics(gltf);
    // Accessors referenced by JOINTS_0 and WEIGHTS_0 attributes must have correct component types
    updateAccessorComponentTypes(gltf);
    // Clamp camera parameters
    clampCameraParameters(gltf);
    // Move legacy technique render states to material properties and add KHR_blend extension blending functions
    moveTechniqueRenderStates(gltf);
    // Add material techniques to KHR_techniques_webgl extension, removing shaders, programs, and techniques
    moveTechniquesToExtension(gltf);
    // Remove empty arrays
    removeEmptyArrays(gltf);
}

export default updateVersion;
