export function getOptimizeStreams(options?: OptimizeOptions):
    NodeJS.ReadWriteStream[] {
  options = options || {};
  const streams = [];

  // compile ES6 JavaScript using babel
  if (options.js && options.js.compile) {
    streams.push(gulpif(/\.js$/, new JSDefaultCompileTransform()));
  }

  // minify code (minify should always be the last transform)
  if (options.html && options.html.minify) {
    streams.push(gulpif(
        /\.html$/,
        new HTMLOptimizeTransform(
            {collapseWhitespace: true, removeComments: true})));
  }
  if (options.css && options.css.minify) {
    streams.push(
        gulpif(/\.css$/, new CSSMinifyTransform({stripWhitespace: true})));
    // TODO(fks): Remove this InlineCSSOptimizeTransform stream once CSS
    // is properly being isolated by splitHtml() & rejoinHtml().
    streams.push(gulpif(
        /\.html$/, new InlineCSSOptimizeTransform({stripWhitespace: true})));
  }
  if (options.js && options.js.minify) {
    streams.push(gulpif(/\.js$/, new JSDefaultMinifyTransform()));
  }

  return streams;
};

gulp.task('html', function () {
    return gulp.src('app/*.html')
        .pipe(useref())
        .pipe(gulpif(f => f.path.endsWith('.js'), uglify()))
        .pipe(gulpif(f => f.path.endsWith('.css'), minifyCss()))
        .pipe(gulp.dest('dist'));
});

gulp.task('html', function () {
    return gulp.src('app/*.html')
        .pipe(useref())
        .pipe(gulpif('*.js', uglify()))
        .pipe(gulpif('*.css', minifyCss()))
        .pipe(gulp.dest('dist'));
});

export function typescriptTask(enableSourcemaps: boolean = false) {
  let files = [`${DIR_SRC}/**/*.ts`, 'typings/browser/**/*.d.ts'];
  return gulp.src(files, {base: DIR_SRC})
      .pipe(gulpif(enableSourcemaps, sourcemaps.init()))
      .pipe(typescript(project))
      .pipe(gulpif(enableSourcemaps, sourcemaps.write()))
      .pipe(gulp.dest(DIR_TMP));
}

task('demos.copySource', (done: Function) => {
  const stream = src([`${DEMOS_SRC_ROOT}/**/*`])
    .pipe(gulpif(/app.module.ts$/, createIndexHTML()))
    .pipe(dest(DIST_DEMOS_ROOT));

  stream.on('end', done);

  function createIndexHTML() {
    const indexTemplate = readFileSync(`${SCRIPTS_ROOT}/${DEMOS_NAME}/demos.template.prod.html`);
    const indexTs = readFileSync(`${SCRIPTS_ROOT}/${DEMOS_NAME}/main.ts`);

    return obj(function (file, enc, next) {
      this.push(new VinylFile({
        base: file.base,
        contents: new Buffer(indexTemplate),
        path: join(dirname(file.path), 'index.html'),
      }));
      this.push(new VinylFile({
        base: file.base,
        contents: new Buffer(indexTs),
        path: join(dirname(file.path), 'main.ts'),
      }));
      next(null, file);
    });
  }
});

export = () => {
    let debug: boolean = argv.debug;
    let dir=join(Config.TMP_DIR, 'jslocal');
    let serviceWorkerFiles = join(dir, '**/service-worker*.js');
    let normalFiles=[join(dir, '**/*.js'),
                    '!' + serviceWorkerFiles];
    if (debug) {
        console.log('copy.js.local - normal files: ', normalFiles);
        console.log('copy.js.local - service worker files: ', serviceWorkerFiles);
    }
    gulp.src(normalFiles)
        .pipe(gulpif(debug, gulpdebug({title:'copy.js.local normal files'})))
        .pipe(gulp.dest(Config.JS_DEST));
    gulp.src(serviceWorkerFiles)
        .pipe(gulpif(debug, gulpdebug({title:'copy.js.local service worker files'})))
        .pipe(gulp.dest(Config.PROD_DEST));
};

function buildTypeScript() {
  typescriptCompiler = ts.createProject('tsconfig.json', {
    typescript: require('typescript')
  });
  let src = gulp.src(project.transpiler.source).pipe(changedInPlace({ firstPass: true }));
  return eventStream
    .merge(src)
    .pipe(plumber({ errorHandler: notify.onError('Error: <%= error.message %>') }))
    .pipe(typescriptCompiler())
    .pipe(gulpif(isJsFile, build.bundle()));
}

export function getOptimizeStreams(options?: OptimizeOptions):
    NodeJS.ReadWriteStream[] {
  options = options || {};
  const streams = [];

  streams.push(gulpif(matchesExt('.js'), new JsTransform(options)));
  streams.push(gulpif(matchesExt('.html'), new HtmlTransform(options)));

  if (options.css && options.css.minify) {
    streams.push(gulpif(
        matchesExtAndNotExcluded('.css', options.css.minify),
        new CSSMinifyTransform({stripWhitespace: true})));
    // TODO(fks): Remove this InlineCSSOptimizeTransform stream once CSS
    // is properly being isolated by splitHtml() & rejoinHtml().
    streams.push(gulpif(
        matchesExtAndNotExcluded('.html', options.css.minify),
        new InlineCSSOptimizeTransform({stripWhitespace: true})));
  }

  return streams;
}

  return new Promise<void>((resolve, reject) => {
    let destinationOptions: vfs.DestOptions;
    if (options && options.mode)
      destinationOptions = { mode: options.mode };

    gulp
      .src(sourcePatterns, options)
      .pipe(gulpif(options && options.flatten, flatten()))
      .pipe(gulp.dest(destination, destinationOptions))
      .on("end", resolve)
      .on("error", reject);
  });

export function optimize(options?: OptimizeOptions) {
  let transforms = [];

  if (options) {
    if (options.js && options.js.minify) {
      transforms.push(new UglifyTransform());
    }
    if (options.css && options.css.stripWhitespace) {
      transforms.push(cssSlam());
    }
    if (options.html) {
      transforms.push(gulpif(/\.html$/, htmlmin(options.html)));
    }
  }
  return compose(transforms);
}