/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

'use strict';
goog.provide('modules.shared.glsRandomUniformBlockCase');
goog.require('framework.common.tcuTestCase');
goog.require('framework.delibs.debase.deMath');
goog.require('framework.delibs.debase.deRandom');
goog.require('framework.opengl.gluShaderUtil');
goog.require('modules.shared.glsUniformBlockCase');

goog.scope(function() {

    var glsRandomUniformBlockCase = modules.shared.glsRandomUniformBlockCase;
    var gluShaderUtil = framework.opengl.gluShaderUtil;
    var glsUniformBlockCase = modules.shared.glsUniformBlockCase;
    var tcuTestCase = framework.common.tcuTestCase;
    var deMath = framework.delibs.debase.deMath;
    var deRandom = framework.delibs.debase.deRandom;

    glsRandomUniformBlockCase.FeatureBits = {
        FEATURE_VECTORS: (1 << 0),
        FEATURE_MATRICES: (1 << 1),
        FEATURE_ARRAYS: (1 << 2),
        FEATURE_STRUCTS: (1 << 3),
        FEATURE_NESTED_STRUCTS: (1 << 4),
        FEATURE_INSTANCE_ARRAYS: (1 << 5),
        FEATURE_VERTEX_BLOCKS: (1 << 6),
        FEATURE_FRAGMENT_BLOCKS: (1 << 7),
        FEATURE_SHARED_BLOCKS: (1 << 8),
        FEATURE_UNUSED_UNIFORMS: (1 << 9),
        FEATURE_UNUSED_MEMBERS: (1 << 10),
        FEATURE_PACKED_LAYOUT: (1 << 11),
        FEATURE_SHARED_LAYOUT: (1 << 12),
        FEATURE_STD140_LAYOUT: (1 << 13),
        FEATURE_MATRIX_LAYOUT: (1 << 14), //!< Matrix layout flags.
        FEATURE_ARRAYS_OF_ARRAYS: (1 << 15)
    };

    /**
     * glsRandomUniformBlockCase.RandomUniformBlockCase class
     * @param {string} name
     * @param {string} description
     * @param {glsUniformBlockCase.BufferMode} bufferMode
     * @param {number} features
     * @param {number} seed
     * @constructor
     * @extends {glsUniformBlockCase.UniformBlockCase}
     */
    glsRandomUniformBlockCase.RandomUniformBlockCase = function(name, description, bufferMode, features, seed) {
        glsUniformBlockCase.UniformBlockCase.call(this, name, description, bufferMode);
        this.m_features = features;
        this.m_maxVertexBlocks = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_VERTEX_BLOCKS) ? 4 : 0);
        this.m_maxFragmentBlocks = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_FRAGMENT_BLOCKS) ? 4 : 0);
        this.m_maxSharedBlocks = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_SHARED_BLOCKS) ? 4 : 0);
        this.m_maxInstances = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_INSTANCE_ARRAYS) ? 3 : 0);
        this.m_maxArrayLength = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS) ? 8 : 0);
        this.m_maxStructDepth = ((features & glsRandomUniformBlockCase.FeatureBits.FEATURE_STRUCTS) ? 2 : 0);
        this.m_maxBlockMembers = 5;
        this.m_maxStructMembers = 4;
        this.m_seed = seed;
        this.m_blockNdx = 1;
        this.m_uniformNdx = 1;
        this.m_structNdx = 1;
    };

    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype = Object.create(glsUniformBlockCase.UniformBlockCase.prototype);
    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.constructor = glsRandomUniformBlockCase.RandomUniformBlockCase;

    /**
     * generateType
     * @param {deRandom.Random} rnd
     * @param {number} typeDepth
     * @param {boolean} arrayOk
     * @return {glsUniformBlockCase.VarType}
     */
    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.generateType = function(rnd, typeDepth, arrayOk) {
        /** @type {number} */ var structWeight = 0.1;
        /** @type {number} */ var arrayWeight = 0.1;
        /** @type {number} */ var flags;

        if (typeDepth < this.m_maxStructDepth && rnd.getFloat() < structWeight) {
            /** @type {number} */ var unusedVtxWeight = 0.15;
            /** @type {number} */ var unusedFragWeight = 0.15;
            /** @type {boolean} */ var unusedOk = (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_MEMBERS) != 0;
            /** @type {Array<glsUniformBlockCase.VarType>} */ var memberTypes = [];
            /** @type {number} */ var numMembers = rnd.getInt(1, this.m_maxStructMembers);

            // Generate members first so nested struct declarations are in correct order.
            for (var ndx = 0; ndx < numMembers; ndx++)
                memberTypes.push(this.generateType(rnd, typeDepth + 1, true));

            /** @type {glsUniformBlockCase.StructType} */ var structType = this.m_interface.allocStruct('s' + this.genName('A'.charCodeAt(0), 'Z'.charCodeAt(0), this.m_structNdx));
            this.m_structNdx += 1;

            assertMsgOptions(this.m_blockNdx <= 'Z'.charCodeAt(0) - 'A'.charCodeAt(0), 'generateType', false, true);
            for (var ndx = 0; ndx < numMembers; ndx++) {
                flags = 0;

                flags |= (unusedOk && rnd.getFloat() < unusedVtxWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_VERTEX : 0;
                flags |= (unusedOk && rnd.getFloat() < unusedFragWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT : 0;

                structType.addMember('m' + ('A'.charCodeAt(0) + ndx), memberTypes[ndx], flags);
            }

            return glsUniformBlockCase.newVarTypeStruct(structType);
        } else if (this.m_maxArrayLength > 0 && arrayOk && rnd.getFloat() < arrayWeight) {
            /** @type {boolean} */ var arraysOfArraysOk = (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_ARRAYS_OF_ARRAYS) != 0;
            /** @type {number} */ var arrayLength = rnd.getInt(1, this.m_maxArrayLength);
            /** @type {glsUniformBlockCase.VarType} */ var elementType = this.generateType(rnd, typeDepth, arraysOfArraysOk);
            return glsUniformBlockCase.newVarTypeArray(elementType, arrayLength);
        } else {
            /** @type {Array<gluShaderUtil.DataType>} */ var typeCandidates = [];

            typeCandidates.push(gluShaderUtil.DataType.FLOAT);
            typeCandidates.push(gluShaderUtil.DataType.INT);
            typeCandidates.push(gluShaderUtil.DataType.UINT);
            typeCandidates.push(gluShaderUtil.DataType.BOOL);

            if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_VECTORS) {
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_VEC2);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_VEC3);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_VEC4);
                typeCandidates.push(gluShaderUtil.DataType.INT_VEC2);
                typeCandidates.push(gluShaderUtil.DataType.INT_VEC3);
                typeCandidates.push(gluShaderUtil.DataType.INT_VEC4);
                typeCandidates.push(gluShaderUtil.DataType.UINT_VEC2);
                typeCandidates.push(gluShaderUtil.DataType.UINT_VEC3);
                typeCandidates.push(gluShaderUtil.DataType.UINT_VEC4);
                typeCandidates.push(gluShaderUtil.DataType.BOOL_VEC2);
                typeCandidates.push(gluShaderUtil.DataType.BOOL_VEC3);
                typeCandidates.push(gluShaderUtil.DataType.BOOL_VEC4);
            }

            if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRICES) {
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT2);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT2X3);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT3X2);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT3);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT3X4);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT4X2);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT4X3);
                typeCandidates.push(gluShaderUtil.DataType.FLOAT_MAT4);
            }

            /** @type {gluShaderUtil.DataType} */ var type = (rnd.choose(typeCandidates)[0]);
            flags = 0;

            if (!gluShaderUtil.isDataTypeBoolOrBVec(type)) {
                // Precision.
                /** @type {Array<number>} */ var precisionCandidates = [glsUniformBlockCase.UniformFlags.PRECISION_LOW, glsUniformBlockCase.UniformFlags.PRECISION_MEDIUM, glsUniformBlockCase.UniformFlags.PRECISION_HIGH];
                flags |= rnd.choose(precisionCandidates)[0];
            }

            return glsUniformBlockCase.newVarTypeBasic(type, flags);
        }
    };

    /**
     * genName
     * @param {number} first
     * @param {number} last
     * @param {number} ndx
     * @return {string}
     */
    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.genName = function(first, last, ndx) {
        /** @type {string} */ var str = '';
        /** @type {number} */ var alphabetLen = last - first + 1;

        while (ndx > alphabetLen) {
            str = String.fromCharCode(first + ((ndx - 1) % alphabetLen)) + str;
            ndx = Math.floor((ndx - 1) / alphabetLen);
        }

        str = String.fromCharCode(first + (ndx % (alphabetLen + 1)) - 1) + str;

        return str;
    };

    /**
     * generateUniform
     * @param {deRandom.Random} rnd
     * @param {glsUniformBlockCase.UniformBlock} block
     */
    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.generateUniform = function(rnd, block) {
        /** @type {number} */ var unusedVtxWeight = 0.15;
        /** @type {number} */ var unusedFragWeight = 0.15;
        /** @type {boolean} */ var unusedOk = (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_UNUSED_UNIFORMS) != 0;
        /** @type {number} */ var flags = 0;
        /** @type {string} */ var name = this.genName('a'.charCodeAt(0), 'z'.charCodeAt(0), this.m_uniformNdx);
        /** @type {glsUniformBlockCase.VarType} */ var type = this.generateType(rnd, 0, true); //TODO: implement this.

        flags |= (unusedOk && rnd.getFloat() < unusedVtxWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_VERTEX : 0;
        flags |= (unusedOk && rnd.getFloat() < unusedFragWeight) ? glsUniformBlockCase.UniformFlags.UNUSED_FRAGMENT : 0;

        block.addUniform(new glsUniformBlockCase.Uniform(name, type, flags));

        this.m_uniformNdx += 1;
    };

    /**
     * generateBlock
     * @param {deRandom.Random} rnd
     * @param {number} layoutFlags
     */
    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.generateBlock = function(rnd, layoutFlags) {
        assertMsgOptions(this.m_blockNdx <= 'z'.charCodeAt(0) - 'a'.charCodeAt(0), 'generateBlock', false, true);

        /** @type {number} */ var instanceArrayWeight = 0.3;
        /** @type {glsUniformBlockCase.UniformBlock} */ var block = this.m_interface.allocBlock('Block' + String.fromCharCode('A'.charCodeAt(0) + this.m_blockNdx));
        /** @type {number} */ var numInstances = (this.m_maxInstances > 0 && rnd.getFloat() < instanceArrayWeight) ? rnd.getInt(0, this.m_maxInstances) : 0;
        /** @type {number} */ var numUniforms = rnd.getInt(1, this.m_maxBlockMembers);

        if (numInstances > 0)
            block.setArraySize(numInstances);

        if (numInstances > 0 || rnd.getBool())
            block.setInstanceName('block' + String.fromCharCode('A'.charCodeAt(0) + this.m_blockNdx));

        // Layout flag candidates.
        /** @type {Array<number>} */ var layoutFlagCandidates = [];
        layoutFlagCandidates.push(0);
        if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_PACKED_LAYOUT)
            layoutFlagCandidates.push(glsUniformBlockCase.UniformFlags.LAYOUT_SHARED);
        if ((this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_SHARED_LAYOUT) && ((layoutFlags & glsUniformBlockCase.UniformFlags.DECLARE_BOTH) != glsUniformBlockCase.UniformFlags.DECLARE_BOTH))
            layoutFlagCandidates.push(glsUniformBlockCase.UniformFlags.LAYOUT_PACKED); // \note packed layout can only be used in a single shader stage.
        if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_STD140_LAYOUT)
            layoutFlagCandidates.push(glsUniformBlockCase.UniformFlags.LAYOUT_STD140);

        layoutFlags |= rnd.choose(layoutFlagCandidates)[0]; //In Javascript, this function returns an array, so taking element 0.

        if (this.m_features & glsRandomUniformBlockCase.FeatureBits.FEATURE_MATRIX_LAYOUT) {
            /** @type {Array<number>}*/ var matrixCandidates = [0, glsUniformBlockCase.UniformFlags.LAYOUT_ROW_MAJOR, glsUniformBlockCase.UniformFlags.LAYOUT_COLUMN_MAJOR];
            layoutFlags |= rnd.choose(matrixCandidates)[0];
        }

        block.setFlags(layoutFlags);

        for (var ndx = 0; ndx < numUniforms; ndx++)
            this.generateUniform(rnd, block);

        this.m_blockNdx += 1;
    };

    /**
     * Initializes the glsRandomUniformBlockCase.RandomUniformBlockCase
     */
    glsRandomUniformBlockCase.RandomUniformBlockCase.prototype.init = function() {
        /** @type {deRandom.Random} */ var rnd = new deRandom.Random(this.m_seed);

        /** @type {number} */ var numShared = this.m_maxSharedBlocks > 0 ? rnd.getInt(1, this.m_maxSharedBlocks) : 0;
        /** @type {number} */ var numVtxBlocks = this.m_maxVertexBlocks - numShared > 0 ? rnd.getInt(1, this.m_maxVertexBlocks - numShared) : 0;
        /** @type {number} */ var numFragBlocks = this.m_maxFragmentBlocks - numShared > 0 ? rnd.getInt(1, this.m_maxFragmentBlocks - numShared) : 0;

        for (var ndx = 0; ndx < numShared; ndx++)
            this.generateBlock(rnd, glsUniformBlockCase.UniformFlags.DECLARE_VERTEX | glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT);

        for (var ndx = 0; ndx < numVtxBlocks; ndx++)
            this.generateBlock(rnd, glsUniformBlockCase.UniformFlags.DECLARE_VERTEX);

        for (var ndx = 0; ndx < numFragBlocks; ndx++)
            this.generateBlock(rnd, glsUniformBlockCase.UniformFlags.DECLARE_FRAGMENT);
    };

});