/*
       Licensed to the Apache Software Foundation (ASF) under one
       or more contributor license agreements.  See the NOTICE file
       distributed with this work for additional information
       regarding copyright ownership.  The ASF licenses this file
       to you under the Apache License, Version 2.0 (the
       "License"); you may not use this file except in compliance
       with the License.  You may obtain a copy of the License at

         http://www.apache.org/licenses/LICENSE-2.0

       Unless required by applicable law or agreed to in writing,
       software distributed under the License is distributed on an
       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
       KIND, either express or implied.  See the License for the
       specific language governing permissions and limitations
       under the License.
*/
/*jslint node: true */
var fs = require("fs-extra");
var path = require("path");
var JoDoc = require("./cordova/jodoc");
var FileHelpers = require("./file_helpers");

var DocsGenerator = (function () {
    'use strict';

    function processEachFile(source_path, callback) {
        var directoryEntries = fs.readdirSync(source_path);
        directoryEntries.forEach(function (dirEntry) {
            var fullPath = path.join(source_path, dirEntry),
                stat;
            if (!fs.existsSync(fullPath)) {
                return;
            }

            stat = fs.lstatSync(fullPath);
            if (stat.isFile()) {
                callback(fullPath);
                return;
            }

            if (stat.isDirectory()) {
                processEachFile(fullPath, callback);
                return;
            }
        });
    }

    /**
    * Creates a new instance of DocsGenerator
    * @param inputDirectory Directory which contains files which has to be processed.
    * @param outputDirectory Directory to which store generated files.
    */
    function DocsGenerator(inputDirectory, outputDirectory) {
        this.input_directory = path.resolve(inputDirectory || FileHelpers.getDefaultInputDirectory());
        this.output_directory = path.resolve(outputDirectory || FileHelpers.getDefaultOutputDirectory());
        this.working_directory = path.join(FileHelpers.getTmpDirectory(), 'docs');
    }

    /* Cordova Build-Time Steps
    * - For each version of the documentation
    *   - Create a work space for the docs processing
    *   - Pre-file processing
    *   - Run joDoc
    *   - Pre-file processing
    *   - Release and cleanup
    */
    DocsGenerator.prototype.run = function (language, version, verbose_mode, timing) {
        var self = this,
            ignore_list = ['.', '..', '.DS_Store'];

        verbose_mode = verbose_mode || 0;
        if (verbose_mode > 0) {
            console.log("Generating docs for lang " + language + " and version " + version);
            // console.log("Clearing output directory");
            if (verbose_mode > 1) {
                console.log("Sources directory: " + this.input_directory);
                console.log("Output directory: " + this.output_directory);
            }
        }

        // fs.removeSync(this.output_directory);

        self.options = {
            verbose: verbose_mode,
            timing: timing
        };
        self.captureExecutionTime("Generate all docs", 0, function () {
            fs.readdirSync(this.input_directory).forEach(function (language_dir) {
                if (ignore_list.indexOf(language_dir) !== -1) {
                    return;
                }

                if (language && language_dir !== language) {
                    return;
                }

                var language_path = path.join(self.input_directory, language_dir);

                fs.readdirSync(language_path).forEach(function (version_dir) {
                    if (ignore_list.indexOf(version_dir) !== -1) {
                        return;
                    }

                    if (version && version_dir !== version) {
                        return;
                    }

                    var output_path = path.join(self.output_directory, language_dir, version_dir),
                        input_path = path.join(self.input_directory, language_dir, version_dir),
                        options = {
                            lang: language_dir,
                            version: version_dir,
                            verbose: verbose_mode,
                            timing: timing
                        };
                    self.options = options;
                    console.log(" => Generating the Cordova Documentation for " + version_dir + "-" + language_dir + "...");
                    self.captureExecutionTime("Generate docs for " + version_dir + "-" + language_dir, 0, function () {
                        try {
                            self.process(input_path, output_path, options);
                        } catch (e) {
                            console.warn("=================================================");
                            console.warn("ERROR: Generating the Cordova Documentation for " + version_dir + "-" + language_dir + " failed.");
                            console.warn(e.stack || e.toString());
                            console.warn("=================================================");
                        }
                    });
                    self.options = {
                        verbose: verbose_mode,
                        timing: timing
                    };
                });
            });
        });
    };

    DocsGenerator.prototype.process = function (input_path, output_path, options) {
        if (options.verbose > 0) {
            console.log("Clearing output directory for lang " + options.lang + " and version " + options.version);
            if (options.verbose > 1) {
                console.log("Output directory: " + output_path);
            }
        }
        
        this.captureExecutionTime("Removing lang output directory", 1, function () {
            fs.removeSync(output_path);
        });
        this.captureExecutionTime("Copy source files to temp", 1, function () {
            fs.copySync(input_path, this.working_directory);
        });
        
        var preprocessPath,
            processPath,
            generated_path;
        this.captureExecutionTime("Pre processing docs", 1, function () {
            preprocessPath = this.before_jodoc(this.working_directory, options);
        });
        this.captureExecutionTime("joDoc-ify", 1, function () {
            processPath = this.jodocify(preprocessPath, options);
        });
        this.captureExecutionTime("Post processing docs", 1, function () {
            generated_path = this.after_jodoc(processPath, options);
        });
        
        this.captureExecutionTime("Moving to results folder", 1, function () {
            fs.ensureDirSync(path.dirname(output_path));
            fs.renameSync(generated_path, output_path);
            fs.removeSync(FileHelpers.getTmpDirectory());
        });
    };

    DocsGenerator.prototype.run_process_sequence = function (sequence_name, source_path, options) {
        var self = this,
            currentModuleDir = path.dirname(module.filename),
            directoryEntries,
            sequenceProcessors,
            processors;
        directoryEntries = fs.readdirSync(path.join(currentModuleDir, "cordova", sequence_name));
        sequenceProcessors = require("./cordova/" + sequence_name + "/index");
        processors = sequenceProcessors.map(function (ProcessorConstructor) {
            return new ProcessorConstructor(options);
        });
        processors.forEach(function (process_module) {
            self.captureExecutionTime("Processor: " + process_module.stage, 1, function () {
                if (options.verbose > 0) {
                    console.log("Stage: " + process_module.stage);
                }

                processEachFile(source_path, function (filename) {
                    self.captureExecutionTime("File: " + filename, 2, function () {
                        process_module.run(filename);
                    });
                });
            });
        });

        return source_path;
    };

    DocsGenerator.prototype.before_jodoc = function (source_path, options) {
        this.run_process_sequence("pre", source_path, options);

        return source_path;
    };

    DocsGenerator.prototype.jodocify = function (source_path, options) {
        var output_directory = path.join(FileHelpers.getTmpDirectory(), 'jodoc');

        new JoDoc(source_path, output_directory, options).run();
        fs.ensureDirSync(output_directory);

        return output_directory;
    };

    DocsGenerator.prototype.after_jodoc = function (source_path, options) {
        this.run_process_sequence("post", source_path, options);
        return source_path;
    };
    
    DocsGenerator.prototype.captureExecutionTime = function (step_name, level, callback) {
        var startDate,
            finishDate,
            timingLevel = -1,
            secondsPassed;
        if (this.options.timing) {
            if (this.options.timing === true) {
                timingLevel = 0;
            } else {
                timingLevel = this.options.timing;
            }
        }
        
        if (timingLevel >= level) {
            startDate = new Date();
            if (this.options.verbose > 0) {
                console.log(startDate, "Start " + step_name);
            }
        }
        
        callback.apply(this);
        if (timingLevel >= level) {
            finishDate = new Date();
            if (this.options.verbose > 0) {
                console.log(finishDate, "Finish " + step_name);
            }
            
            secondsPassed = (finishDate.valueOf() - startDate.valueOf()) / 1000;
            console.log(step_name + ". Total time: ", secondsPassed);
        }
    };

    return DocsGenerator;
}());
module.exports = DocsGenerator;