/*
 *  Created by Phil on 02/11/2010.
 *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
#ifndef TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED

#include "catch_config.hpp"
#include "catch_common.h"
#include "catch_clara.h"

#include <fstream>
#include <ctime>

namespace Catch {

    inline clara::Parser makeCommandLineParser( ConfigData& config ) {

        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
                std::ifstream f( filename.c_str() );
                if( !f.is_open() )
                    return clara::ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );

                std::string line;
                while( std::getline( f, line ) ) {
                    line = trim(line);
                    if( !line.empty() && !startsWith( line, '#' ) ) {
                        if( !startsWith( line, '"' ) )
                            line = '"' + line + '"';
                        config.testsOrTags.push_back( line + ',' );
                    }
                }
                return clara::ParserResult::ok( clara::ParseResultType::Matched );
            };


        using namespace clara;
        auto cli
            = ExeName( config.processName )
            + Help( config.showHelp )
            + Opt( config.listTests )
                ["-l"]["--list-tests"]
                ( "list all/matching test cases" )
            + Opt( config.listTags )
                ["-t"]["--list-tags"]
                ( "list all/matching tags" )
            + Opt( config.showSuccessfulTests )
                ["-s"]["--success"]
                ( "include successful tests in output" )
            + Opt( config.shouldDebugBreak )
                ["-b"]["--break"]
                ( "break into debugger on failure" )
            + Opt( config.noThrow )
                ["-e"]["--nothrow"]
                ( "skip exception tests" )
            + Opt( config.showInvisibles )
                ["-i"]["--invisibles"]
                ( "show invisibles (tabs, newlines)" )
            + Opt( config.outputFilename, "filename" )
                ["-o"]["--out"]
                ( "output filename" )
            + Opt( config.reporterNames, "name" )
                ["-r"]["--reporter"]
                ( "reporter to use (defaults to console)" )
            + Opt( config.name, "name" )
                ["-n"]["--name"]
                ( "suite name" )
            + Opt( [&]( bool ){ config.abortAfter = 1; } )
                ["-a"]["--abort"]
                ( "abort at first failure" )
            + Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
                ["-x"]["--abortx"]
                ( "abort after x failures" )
            + Opt( [&]( std::string const& warning ) {
                        if( warning != "NoAssertions" )
                            return clara::ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
                        config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
                        return clara::ParserResult::ok( ParseResultType::Matched );
                    }, "warning name" )
                ["-w"]["--warn"]
                ( "enable warnings" )
            + Opt( [&]( bool ) { config.showDurations = ShowDurations::Always; } )
                ["-d"]["--durations"]
                ( "show test durations" )
            + Opt( loadTestNamesFromFile, "filename" )
                ["-f"]["--input-file"]
                ( "load test names to run from a file" )
            + Opt( config.filenamesAsTags )
                ["-#"]["--filenames-as-tags"]
                ( "adds a tag for the filename" )
            + Opt( config.sectionsToRun, "section name" )
                ["-c"]["--section"]
                ( "specify section to run" )
            + Opt( config.listTestNamesOnly )
                ["--list-test-names-only"]
                ( "list all/matching test cases names only" )
            + Opt( config.listReporters )
                ["--list-reporters"]
                ( "list all reporters" )
            + Opt( [&]( std::string const& order ) {
                        if( startsWith( "declared", order ) )
                            config.runOrder = RunTests::InDeclarationOrder;
                        else if( startsWith( "lexical", order ) )
                            config.runOrder = RunTests::InLexicographicalOrder;
                        else if( startsWith( "random", order ) )
                            config.runOrder = RunTests::InRandomOrder;
                        else
                            return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
                        return clara::ParserResult::ok( ParseResultType::Matched );
                    }, "decl|lex|rand" )
                ["--order"]
                ( "test case order (defaults to decl)" )
            + Opt( [&]( std::string const& seed ) {
                        if( seed != "time" )
                            return clara::detail::convertInto( seed, config.rngSeed );
                        config.rngSeed = static_cast<unsigned int>( std::time(0) );
                        return clara::ParserResult::ok( ParseResultType::Matched );
                    }, "'time'|number" )
                ["--rng-seed"]
                ( "set a specific seed for random numbers" )
            + Opt( [&]( std::string const& useColour ) {
                            auto mode = toLower( useColour );

                            if( mode == "yes" )
                                config.useColour = UseColour::Yes;
                            else if( mode == "no" )
                                config.useColour = UseColour::No;
                            else if( mode == "auto" )
                                config.useColour = UseColour::Auto;
                            else
                                return clara::ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
                        return clara::ParserResult::ok( ParseResultType::Matched );
                    }, "yes|no" )
                ["--use-colour"]
                ( "should output be colourised" )

            + Arg( config.testsOrTags, "test name|pattern|tags" )
                ( "which test or tests to use" );

        return cli;
    }

} // end namespace Catch

#endif // TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED