declare var module: any;
declare function require(name:string);
declare var __filename: string;
declare var __dirname: string;

import base = require("./base");

var gulp = require('gulp');
var path = require('path');
var $ = require('gulp-load-plugins')({lazy: true});
var _ = require('lodash');
var runSequence = require('run-sequence');
var gutil = $.util;
var merge = require('merge-stream');

var coffeeScriptCompile = require('./streams/coffeeScriptCompile');
var coffeeScriptLint = require('./streams/coffeeScriptLint');
var typeScriptLint = require('./streams/typeScriptLint');
var typeScriptCompile = require('./streams/typeScriptCompile');
var stylusCompile = require('./streams/stylusCompile');

class CompileJavaScript extends base.BaseTask {
  constructor() {
    super();
    return this;
  }

  static watch:boolean = true;
  static dependency:any = ['cleanJavaScript', 'cleanCss'];
  static taskName:string = 'compileAngular';
  static required:Array<string> = [
    'gulp-order',
    'gulp-typescript',
    'gulp-bytediff',
    'gulp-coffee',
    'gulp-wrap-amd',
    'gulp-concat',
    'gulp-sourcemaps',
    'gulp-stylus',
    'gulp-less',
    'gulp-csso'

  ];

  static config(task, tasks, userOptions) {
    return {
      files: [
        './source/client/**/*.d.ts',
        './source/client/**/*.ts',
        './source/client/**/*.coffee',
        './source/client/**/*.js',
        './source/client/**/*.styl',
        './source/client/**/*.css',
        './source/client/**/*.less'
      ],
      file: {
        script: [
          './source/client/**/*.d.ts',
          './source/client/**/*.ts',
          './source/client/**/*.coffee',
          './source/client/**/*.js'
        ],
        css: [
          './source/client/**/*.styl',
          './source/client/**/*.css',
          './source/client/**/*.less'
        ]
      },
      base: 'source/client/',
      /* Don't start patterns with `./` - they will never match. Just leave out `./` */
      csso: {
        filter: /[.]min.*$/,
        options: {}
      },
      orderFileExport: ['source/*.js','source/**/*.js','source/**/**/*.js'],
      watch: ['cleanJavaScript', 'cleanCss'],
      typescript: {
        removeComments: false,
        noImplicitAny: false,
        noLib: false,
        noEmitOnError: false,
        target: 'ES5',
        module: 'commonjs',
        sourceRoot: '.tmp/ts-debugging/',
        declarationFiles: true,
        noExternalResolve: false,
        sortOutput: true
      },
      amdwrapper: {
        filter: function (file) {
          return !!file.path.match(/[.]amd.*$/);
        },
        options:{
          deps: ['require','exports','module'], // dependency array
          params: ['require','exports','module'], // params for callback
          exports: 'exports || module'
        }
      },
      uglify: {
        filter: /[.]min.*$/,
        options: {
          mangle: true,
          preserveComments: true,
          output:{
            indent_start: 0,     // start indentation on every line (only when `beautify`)
            indent_level: 4,     // indentation level (only when `beautify`)
            quote_keys: false, // quote all keys in object literals?
            space_colon: true,  // add a space after colon signs?
            ascii_only: false, // output ASCII-safe? (encodes Unicode characters as ASCII)
            inline_script: false, // escape "</script"?
            width: 80,    // informative maximum line width (for beautified output)
            max_line_len: 32000, // maximum line length (for non-beautified output)
            beautify: false, // beautify output?
            source_map: null,  // output a source map
            bracketize: false, // use brackets every time?
            comments: false, // output comments?
            semicolons: true  // use semicolons to separate statements? (otherwise
          },
          compress: {
            sequences: true,  // join consecutive statemets with the “comma operator”
            properties: true,  // optimize property access: a["foo"] → a.foo
            dead_code: true,  // discard unreachable code
            drop_debugger: true,  // discard “debugger” statements
            unsafe: false, // some unsafe optimizations (see below)
            conditionals: true,  // optimize if-s and conditional expressions
            comparisons: true,  // optimize comparisons
            evaluate: true,  // evaluate constant expressions
            booleans: true,  // optimize boolean expressions
            loops: true,  // optimize loops
            unused: true,  // drop unused variables/functions
            hoist_funs: true,  // hoist function declarations
            hoist_vars: false, // hoist variable declarations
            if_return: true,  // optimize if-s followed by return/continue
            join_vars: true,  // join var declarations
            cascade: true,  // try to cascade `right` into `left` in sequences
            side_effects: true,  // drop side-effect-free statements
            warnings: true,  // warn about potentially dangerous optimizations/code
            global_defs: {}     // global definitions
          }
        }
      },
      filter: function (file) {
        return !file.path.toString().match(/[.]html.coffee$/);
      },
      concat: true
    };
  }

  static gulp(options, settings, task, tasks):void {
    CompileJavaScript.checkArguments(options, settings, task, tasks);

    var tsProject = $.typescript.createProject(settings.typescript);
    var filter = $.filter(settings.filter);

    var scriptStream = gulp
      .src(settings.file.script, {base: settings.base})
      .pipe(filter);

    scriptStream = coffeeScriptLint(scriptStream, options.coffeeLint);
    scriptStream = coffeeScriptCompile(scriptStream);
    scriptStream = typeScriptLint(scriptStream, options.tslint);
    scriptStream = typeScriptCompile(scriptStream, tsProject);

    scriptStream
      .pipe($.plumber())
      .pipe($.order(settings.orderFileExport))
      .pipe($.print())
      .pipe($.bytediff.start())
      .pipe($["if"](settings.uglify.filter, $.uglify(settings.uglify.options)))
      .pipe($["if"](settings.amdwrapper.filter, $.wrapAmd(settings.amdwrapper.options)))
      .pipe($.bytediff.stop())
      .pipe($["if"](settings.concat, $.concat('all.js')))
      .pipe(gulp.dest(settings.dist || options.dist));

    var cssStream = gulp.src(settings.file.css, {
      base: settings.base
    });

    cssStream = stylusCompile(cssStream);

    cssStream
      .pipe($.print())
      .pipe($.plumber())
      .pipe($["if"](settings.csso.filter, $.csso(settings.csso.options)))
      .pipe(gulp.dest(settings.dist || options.dist));


    return merge(scriptStream, cssStream);
  }

}

export = CompileJavaScript;