import arraySlice from '../Core/arraySlice.js';
import ComponentDatatype from '../Core/ComponentDatatype.js';
import defined from '../Core/defined.js';
import FeatureDetection from '../Core/FeatureDetection.js';
import TaskProcessor from '../Core/TaskProcessor.js';
import ForEach from '../ThirdParty/GltfPipeline/ForEach.js';
import when from '../ThirdParty/when.js';

    /**
     * @private
     */
    function DracoLoader() {}

    // Maximum concurrency to use when decoding draco models
    DracoLoader._maxDecodingConcurrency = Math.max(FeatureDetection.hardwareConcurrency - 1, 1);

    // Exposed for testing purposes
    DracoLoader._decoderTaskProcessor = undefined;
    DracoLoader._taskProcessorReady = false;
    DracoLoader._getDecoderTaskProcessor = function () {
        if (!defined(DracoLoader._decoderTaskProcessor)) {
            var processor = new TaskProcessor('decodeDraco', DracoLoader._maxDecodingConcurrency);
            processor.initWebAssemblyModule({
                modulePath : 'ThirdParty/Workers/draco_wasm_wrapper.js',
                wasmBinaryFile : 'ThirdParty/draco_decoder.wasm',
                fallbackModulePath : 'ThirdParty/Workers/draco_decoder.js'
            }).then(function () {
                DracoLoader._taskProcessorReady = true;
            });
            DracoLoader._decoderTaskProcessor = processor;
        }

        return DracoLoader._decoderTaskProcessor;
    };

    /**
     * Returns true if the model uses or requires KHR_draco_mesh_compression.
     *
     * @private
     */
    DracoLoader.hasExtension = function(model) {
        return (defined(model.extensionsRequired.KHR_draco_mesh_compression)
            || defined(model.extensionsUsed.KHR_draco_mesh_compression));
    };

    function addBufferToLoadResources(loadResources, typedArray) {
        // Create a new id to differentiate from original glTF bufferViews
        var bufferViewId = 'runtime.' + Object.keys(loadResources.createdBufferViews).length;

        var loadResourceBuffers = loadResources.buffers;
        var id = Object.keys(loadResourceBuffers).length;
        loadResourceBuffers[id] = typedArray;
        loadResources.createdBufferViews[bufferViewId] = {
            buffer : id,
            byteOffset : 0,
            byteLength : typedArray.byteLength
        };

        return bufferViewId;
    }

    function addNewVertexBuffer(typedArray, model, context) {
        var loadResources = model._loadResources;
        var id = addBufferToLoadResources(loadResources, typedArray);
        loadResources.vertexBuffersToCreate.enqueue(id);
        return id;
    }

    function addNewIndexBuffer(indexArray, model, context) {
        var typedArray = indexArray.typedArray;
        var loadResources = model._loadResources;
        var id = addBufferToLoadResources(loadResources, typedArray);
        loadResources.indexBuffersToCreate.enqueue({
            id : id,
            componentType : ComponentDatatype.fromTypedArray(typedArray)
        });

        return {
            bufferViewId : id,
            numberOfIndices : indexArray.numberOfIndices
        };
    }

    function scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context) {
        if (!DracoLoader._taskProcessorReady) {
            // The task processor is not ready to schedule tasks
            return;
        }

        var taskData = loadResources.primitivesToDecode.peek();
        if (!defined(taskData)) {
            // All primitives are processing
            return;
        }

        var promise = decoderTaskProcessor.scheduleTask(taskData, [taskData.array.buffer]);
        if (!defined(promise)) {
            // Cannot schedule another task this frame
            return;
        }

        loadResources.activeDecodingTasks++;
        loadResources.primitivesToDecode.dequeue();
        return promise.then(function (result) {
            loadResources.activeDecodingTasks--;

            var decodedIndexBuffer = addNewIndexBuffer(result.indexArray, model, context);

            var attributes = {};
            var decodedAttributeData = result.attributeData;
            for (var attributeName in decodedAttributeData) {
                if (decodedAttributeData.hasOwnProperty(attributeName)) {
                    var attribute = decodedAttributeData[attributeName];
                    var vertexArray = attribute.array;
                    var vertexBufferView = addNewVertexBuffer(vertexArray, model, context);

                    var data = attribute.data;
                    data.bufferView = vertexBufferView;

                    attributes[attributeName] = data;
                }
            }

            model._decodedData[taskData.mesh + '.primitive.' + taskData.primitive] = {
                bufferView : decodedIndexBuffer.bufferViewId,
                numberOfIndices : decodedIndexBuffer.numberOfIndices,
                attributes : attributes
            };
        });
    }

    DracoLoader._decodedModelResourceCache = undefined;

    /**
     * Parses draco extension on model primitives and
     * adds the decoding data to the model's load resources.
     *
     * @private
     */
    DracoLoader.parse = function(model, context) {
        if (!DracoLoader.hasExtension(model)) {
            return;
        }

        var loadResources = model._loadResources;
        var cacheKey = model.cacheKey;
        if (defined(cacheKey)) {
            if (!defined(DracoLoader._decodedModelResourceCache)) {
                if (!defined(context.cache.modelDecodingCache)) {
                    context.cache.modelDecodingCache = {};
                }

                DracoLoader._decodedModelResourceCache = context.cache.modelDecodingCache;
            }

            // Decoded data for model will be loaded from cache
            var cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
            if (defined(cachedData)) {
                cachedData.count++;
                loadResources.pendingDecodingCache = true;
                return;
            }
        }

        var dequantizeInShader = model._dequantizeInShader;
        var gltf = model.gltf;
        ForEach.mesh(gltf, function(mesh, meshId) {
            ForEach.meshPrimitive(mesh, function(primitive, primitiveId) {
                if (!defined(primitive.extensions)) {
                    return;
                }

                var compressionData = primitive.extensions.KHR_draco_mesh_compression;
                if (!defined(compressionData)) {
                    return;
                }

                var bufferView = gltf.bufferViews[compressionData.bufferView];
                var typedArray = arraySlice(gltf.buffers[bufferView.buffer].extras._pipeline.source, bufferView.byteOffset, bufferView.byteOffset + bufferView.byteLength);
                loadResources.primitivesToDecode.enqueue({
                    mesh : meshId,
                    primitive : primitiveId,
                    array : typedArray,
                    bufferView : bufferView,
                    compressedAttributes : compressionData.attributes,
                    dequantizeInShader : dequantizeInShader
                });
            });
        });
    };

    /**
     * Schedules decoding tasks available this frame.
     * @private
     */
    DracoLoader.decodeModel = function(model, context) {
        if (!DracoLoader.hasExtension(model)) {
            return when.resolve();
        }

        var loadResources = model._loadResources;
        var cacheKey = model.cacheKey;
        if (defined(cacheKey) && defined(DracoLoader._decodedModelResourceCache)) {
            var cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
            // Load decoded data for model when cache is ready
            if (defined(cachedData) && loadResources.pendingDecodingCache) {
                return when(cachedData.ready, function () {
                    model._decodedData = cachedData.data;
                    loadResources.pendingDecodingCache = false;
                });
            }

            // Decoded data for model should be cached when ready
            DracoLoader._decodedModelResourceCache[cacheKey] = {
                ready : false,
                count : 1,
                data : undefined
            };
        }

        if (loadResources.primitivesToDecode.length === 0) {
            // No more tasks to schedule
            return when.resolve();
        }

        var decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
        var decodingPromises = [];

        var promise = scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context);
        while (defined(promise)) {
            decodingPromises.push(promise);
            promise = scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context);
        }

        return when.all(decodingPromises);
    };

    /**
     * Decodes a compressed point cloud. Returns undefined if the task cannot be scheduled.
     * @private
     */
    DracoLoader.decodePointCloud = function(parameters) {
        var decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
        if (!DracoLoader._taskProcessorReady) {
            // The task processor is not ready to schedule tasks
            return;
        }
        return decoderTaskProcessor.scheduleTask(parameters, [parameters.buffer.buffer]);
    };

    /**
     * Caches a models decoded data so it doesn't need to decode more than once.
     * @private
     */
    DracoLoader.cacheDataForModel = function(model) {
        var cacheKey = model.cacheKey;
        if (defined(cacheKey) && defined(DracoLoader._decodedModelResourceCache)) {
            var cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
            if (defined(cachedData)) {
                cachedData.ready = true;
                cachedData.data = model._decodedData;
            }
        }
    };

    /**
     * Destroys the cached data that this model references if it is no longer in use.
     * @private
     */
    DracoLoader.destroyCachedDataForModel = function(model) {
        var cacheKey = model.cacheKey;
        if (defined(cacheKey) && defined(DracoLoader._decodedModelResourceCache)) {
            var cachedData = DracoLoader._decodedModelResourceCache[cacheKey];
            if (defined(cachedData) && --cachedData.count === 0) {
                delete DracoLoader._decodedModelResourceCache[cacheKey];
            }
        }
    };
export default DracoLoader;