import * as smartpromise from '@push.rocks/smartpromise';
import * as through2 from 'through2';
import { Transform } from 'stream';

export type TExecutionMode = 'forEach' | 'forFirst' | 'atEnd';

export interface IPromiseFunction {
  (file?, enc?): PromiseLike<any>;
}

let defaultExport = (
  functionsToExecuteArg: IPromiseFunction | IPromiseFunction[],
  executionModeArg: TExecutionMode = 'forEach'
): Transform => {
  let promiseArray = [];
  let runFunction = function(functionArg, file, enc) {
    let returnValue = functionArg(file, enc);
    if (typeof returnValue !== 'undefined' && typeof returnValue.then !== 'undefined') {
      promiseArray.push(returnValue);
    }
  };

  let checkAndRunFunction = function(file, enc) {
    if (typeof functionsToExecuteArg === 'function') {
      runFunction(functionsToExecuteArg, file, enc);
    } else if (Array.isArray(functionsToExecuteArg)) {
      for (let anyFunction in functionsToExecuteArg) {
        runFunction(functionsToExecuteArg[anyFunction], file, enc);
      }
    } else {
      throw new Error('gulp-callfunction: something is strange with the given arguments');
    }
    return Promise.all(promiseArray);
  };

  let hasExecutedOnce = false;
  let forEach = function(file, enc, cb) {
    // the forEach function is called for every chunk
    switch (executionModeArg) {
      case 'forEach':
        checkAndRunFunction(file, enc).then(function() {
          cb(null, file);
        });
        break;
      case 'forFirst':
        if (hasExecutedOnce) {
          checkAndRunFunction(file, enc).then(function() {
            cb(null, file);
          });
        } else {
          cb(null, file);
        }
        hasExecutedOnce = true;
        break;
      case 'atEnd':
        cb();
        break;
      default:
        break;
    }
  };

  let atEnd = function(cb) {
    if (executionModeArg === 'atEnd') {
      checkAndRunFunction(null, null).then(function() {
        cb();
      });
    } else {
      cb();
    }
  };
  return through2.obj(forEach, atEnd);
};

export let forEach = (funcArg: IPromiseFunction) => {
  return defaultExport(funcArg, 'forEach');
};

export let forFirst = (funcArg: IPromiseFunction) => {
  return defaultExport(funcArg, 'forFirst');
};

export let atEnd = (funcArg: IPromiseFunction) => {
  return defaultExport(funcArg, 'atEnd');
};

export default defaultExport;