// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

import {DataType} from '../../../wasm-common';
import {TensorView} from '../../tensor-view';
import {ShapeUtil} from '../../util';
import {AttributeWithCacheKey, createAttributeWithCacheKey} from '../attribute-with-cache-key';
import {ComputeContext, ProgramInfo} from '../types';

import {createTensorShapeVariables, getElementAt, inputVariable, outputVariable, ShaderHelper} from './common';


export interface CumSumAttributes extends AttributeWithCacheKey {
  readonly exclusive: boolean;
  readonly reverse: boolean;
}
const createCumsumProgramInfo =
    (inputType: number, inputShape: readonly number[], axisInput: TensorView, attributes: CumSumAttributes):
        ProgramInfo => {
          const outputSize = ShapeUtil.size(inputShape);  // outputShape is same as inputShape.
          const rank = inputShape.length;                 // input/output rank
          const input = inputVariable('input', inputType, rank);
          const output = outputVariable('output', inputType, rank);
          const axisValue = axisInput.dataType === DataType.int32 ? axisInput.getInt32Array()[0] :
                                                                    Number(axisInput.getBigInt64Array()[0]);
          const axis = ShapeUtil.normalizeAxis(axisValue, rank);
          const getShaderSource = (shaderHelper: ShaderHelper) => {
            const index = ` i32(${input.indicesGet('inputIndices', 'uniforms.axis')}) `;
            const max = getElementAt('uniforms.input_shape', 'uniforms.axis', rank);
            const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? ' + 1' : '') : '0';
            const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? '' : ' + 1');
            return `
                ${
                shaderHelper.registerUniform('outputSize', 'u32')
                    .registerUniform('axis', 'u32')
                    .declareVariables(input, output)}
                ${shaderHelper.mainStart()}
                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}
                  var inputIndices = ${output.offsetToIndices('global_idx')};
                  var sum = ${output.type.value}(0);
                  let first : i32 = ${lowerLimit};
                  let last : i32 = ${upperLimit};
                  for (var i : i32 = first; i < last; i++) {
                    ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(i)')};
                    sum = sum + ${input.getByIndices('inputIndices')};
                  }
                  ${output.setByOffset('global_idx', 'sum')};
                }`;
          };
          return {
            name: 'CumSum',
            shaderCache: {hint: attributes.cacheKey, inputDependencies: ['rank']},
            getRunData: () => ({
              outputs: [{dims: inputShape, dataType: inputType}],
              dispatchGroup: {x: Math.ceil(outputSize / 64 /* workgroup size */)},
              programUniforms: [
                {type: DataType.uint32, data: outputSize}, {type: DataType.uint32, data: axis},
                ...createTensorShapeVariables(inputShape, inputShape)
              ]

            }),
            getShaderSource
          };
        };


export const cumsum = (context: ComputeContext, attributes: CumSumAttributes): void => {
  const inputShape = context.inputs[0].dims;
  const inputType = context.inputs[0].dataType;
  const axis = context.inputs[1];
  context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), {inputs: [0]});
};

export const parseCumSumAttributes = (attributes: Record<string, unknown>): CumSumAttributes => {
  const exclusive = attributes.exclusive as number === 1;
  const reverse = attributes.reverse as number === 1;
  return createAttributeWithCacheKey({exclusive, reverse});
};