/**
 ** Copyright (c) 2008-2010 Illumina, Inc.
 **
 ** This software is covered by the "Illumina Genome Analyzer Software
 ** License Agreement" and the "Illumina Source Code License Agreement",
 ** and certain third party copyright/licenses, and any user of this
 ** source file is bound by the terms therein (see accompanying files
 ** Illumina_Genome_Analyzer_Software_License_Agreement.pdf and
 ** Illumina_Source_Code_License_Agreement.pdf and third party
 ** copyright/license notices).
 **
 ** This file is part of the Consensus Assessment of Sequence And VAriation
 ** (CASAVA) software package.
 **
 ** \file CASAVA.cpp
 **
 ** \brief CASAVA
 **
 ** This is main entry point to all CASAVA C++ applications. Please keep is
 ** simple and wrap each application in Application class.
 **
 ** \author Lukasz Szajkowski
 **/

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <getopt.h>

#include "common/Exceptions.hh"
#include "common/Const.hh"
#include "applications/Application.hh"
#include "applications/CasavaOptions.hh"

#include "applications/AlignCandIndelReads.hh"
#include "applications/IndelFinder.hh"
#include "applications/ClusterFinder.hh"
#include "applications/ClusterMerger.hh"
#include "applications/ExportExample.hh"
#include "applications/Export2Fastq.hh"
#include "applications/Sam2Export.hh"
#include "applications/AlignContig.hh"
#include "applications/CheckOrder.hh"
#include "applications/SmallAssembler.hh"

using namespace casava::common;
using namespace ca::applications;



static
void
dump_cl(int argc,
        char* argv[],
        std::ostream& os) {

    os << "cmdline:";
    for(int i(0);i<argc;++i){
        os << ' ';
        os << argv[i];
    }
    os << std::endl;
}



int main(int argc, char* argv[]) {

	CasavaOptions casavaOptions;

        bool is_exception(false);
        std::ostream& log_os(std::cerr);

	try {
            if (casava::common::Options::RUN == casavaOptions.init(argc, argv)) {
			if (casavaOptions.applicationType().compare(
							Const::get().IndelFinder()) == 0) {
				IndelFinder indelFinderApp(casavaOptions);
				return indelFinderApp.run();
			} else if (casavaOptions.applicationType().compare(
            				Const::get().AlignCandIndelReads()) == 0) {
				AlignCandIndelReads alignCandIndelReads(casavaOptions);
				return alignCandIndelReads.run();
			} else if (casavaOptions.applicationType().compare(
            				Const::get().ClusterFinder()) == 0) {
				ClusterFinder clusterFinder(casavaOptions);
				return clusterFinder.run();
			} else if (casavaOptions.applicationType().compare(
            				Const::get().ClusterMerger()) == 0) {
				ClusterMerger clusterMerger(casavaOptions);
				return clusterMerger.run();
			} else if (casavaOptions.applicationType().compare(
							Const::get().AlignContig()) == 0) {
				AlignContig alignContigApp(casavaOptions);
				return alignContigApp.run();
            } else if (casavaOptions.applicationType().compare(
					Const::get().SmallAssembler()) == 0) {
				SmallAssembler smallAssemblerApp(casavaOptions);
				return smallAssemblerApp.run();
			} else if (casavaOptions.applicationType().compare(
            				Const::get().Export2Fastq()) == 0) {
             	Export2Fastq export2FastqApp(casavaOptions);
                return export2FastqApp.run();
			} else if (casavaOptions.applicationType().compare(
							Const::get().ExportExample()) == 0) {
				ExportExample exportExample(casavaOptions);
				return exportExample.run();
			} else if (casavaOptions.applicationType().compare(
            				Const::get().Sam2Export()) == 0) {
				Sam2Export sam2ExportApp(casavaOptions);
                return sam2ExportApp.run();
			} else if (casavaOptions.applicationType().compare(
							Const::get().CheckOrder()) == 0) {
				CheckOrder checkOrderApp(casavaOptions);
				return checkOrderApp.run();
			}
		}
        } catch(const casava::common::CasavaException& e) {
            log_os << "ERROR:  EXCEPTION: " << e.getContext() << ": " << e.getMessage() << "\n";
            is_exception=true;
	} catch (const std::exception& e) {
            log_os << "ERROR:  EXCEPTION: " << e.what() << "\n";
            is_exception=true;
        } catch(...) {
            log_os << "ERROR: UNKNOWN EXCEPTION\n";
            is_exception=true;
        }

        if(is_exception) {
            log_os << "...caught in main()\n";
            dump_cl(argc,argv,log_os);
            exit(EXIT_FAILURE);
        } else {
            return EXIT_SUCCESS;
        }
}