import { Order } from 'blockly/javascript';
/**
 * @category Lists
 * @module AdvancedLists
 */
/**
 * Joins elements of an array into a string using a specified delimiter.
 *
 * @param {Array} array - The array to convert to string
 * @param {String} delimiter - The delimiter to use between values
 * @returns {String} array.join(delimiter)
 */
function joinArray(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    const delimiter = generator.valueToCode(block, 'DELIMITER', Order.NONE) || '';
    return [`${array}.join(${delimiter})`, Order.VOID];
}
/**
 * Removes duplicate elements from an array.
 *
 * @param {Array} array - The array to delete duplicates from
 * @returns {String} - [...new Set(array)]
 */
function removeDuplicates(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    return [`[...new Set(${array})]`, Order.VOID];
}
/**
 * Finds the maximum value in an array.
 *
 * @param {Array} array - The array to find max value of
 * @returns {String} getMaxValue(array)
 */
function getMaxValue(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    const getMaxValue = generator.provideFunction_('get_max_value', `function ${generator.FUNCTION_NAME_PLACEHOLDER_}(array) {
     
    const maxValue = array.flat().reduce((max, current) => (current > max ? current : max), -Infinity);

    return maxValue
}`);
    return [`${getMaxValue}(${array})`, Order.VOID];
}
/**
 * Filters an array to include only elements less than or equal to a specified maximum value.
 *
 * @param {Array} array - The array to filter
 * @param {Number} max - The maximum cutoff value
 * @returns {String} array.filter((i) => i <= max)
 */
function filterOnMaValue(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    const max = generator.valueToCode(block, 'MAX', Order.NONE) || '';
    return [`${array}.filter(i => i<=${max})`, Order.VOID];
}
/**
 * Pushes a value into an array.
 *
 * @param {Array} array - The array
 * @param {Number} value - The value to push at the end
 * @returns {String} array.push(value)
 */
function pushIntoArray(block, generator) {
    const value = generator.valueToCode(block, 'VALUE', Order.NONE) || '';
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    return `${array}.push(${value})`;
}
/**
 * Splits an array into two parts based on a specified index and axis.
 *
 * @param {Array} array - The array
 * @param {Number} axis - 0 for row split, 1 for column split
 * @param {Number} index - The index to split at
 * @returns {String} if axis is 0 then [array.slice(0, index), array.slice(index)] else [array.map((item) => item.slice(0, index))[0], array.map((item) => item.slice(index))[0]]
 */
function splitData(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    const axis = block.getFieldValue('AXIS') || '';
    const index = generator.valueToCode(block, 'INDEX', Order.NONE) || '';
    if (axis === '0') {
        return [`[${array}.slice(0,${index}),${array}.slice(${index})]`, Order.VOID];
    }
    else {
        return [`[${array}.map(a => a.slice(0,${index})[0]),${array}.map(a => a.slice(${index})[0])]`, Order.VOID];
    }
}
/**
 * Pads an array with zeros up to a specified length.
 *
 * @param {Array} array - The array
 * @param {Number} len - The desired length of the array
 * @returns {String} pad_array(array, len)
 */
function arrayPad(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    const len = generator.valueToCode(block, 'LEN', Order.NONE) || '';
    const padArray = generator.provideFunction_('pad_array', `function ${generator.FUNCTION_NAME_PLACEHOLDER_}(array,max_length) {
     
    const _arr = array.slice(0,max_length)

    while(_arr.length < max_length){
      _arr.unshift(0)
    }

    return _arr
}`);
    return [`${padArray}(${array},${len})`, Order.VOID];
}
/**
 * Shuffles the elements of an array randomly.
 *
 * @param {Array} array - The array
 * @returns {String} shuffle_array(array)
 */
function arrayShuffle(block, generator) {
    const array = generator.valueToCode(block, 'ARRAY', Order.NONE) || '';
    const shuffleArray = generator.provideFunction_('shuffle_array', `function ${generator.FUNCTION_NAME_PLACEHOLDER_}(array) {

     for (let i = array.length - 1; i > 0; i--) {
  
    const randomIndex = Math.floor(Math.random() * (i + 1));
    
    [array[i], array[randomIndex]] = [array[randomIndex], array[i]];
  }
  return array;
}`);
    return [`${shuffleArray}(${array})`, Order.VOID];
}
export const additionalListsBlockGenerator = {
    array_join: joinArray,
    remove_duplicates: removeDuplicates,
    get_max_value: getMaxValue,
    filter_array_on_max_value: filterOnMaValue,
    array_push: pushIntoArray,
    data_split: splitData,
    array_pad: arrayPad,
    array_shuffle: arrayShuffle,
};
//# sourceMappingURL=generators.js.map