// -*- mode: c++; indent-tabs-mode: nil; -*-
//
// Copyright 2009 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).
//
//

/// \file
///
/// \author Chris Saunders
///

#include "blt/blt_info.hh"
#include "blt/blt_run.hh"

#include "blt_common/blt_arg_parse.hh"
#include "blt_common/blt_arg_validate.hh"
#include "blt_util/blt_exception.hh"
#include "blt_common/blt_shared.hh"
#include "blt_util/log.hh"
#include "common/Exceptions.hh"

#include <cstdlib>

#include <iostream>
#include <sstream>



namespace {
const prog_info& pinfo(blt_info::get());
}



static
void
try_main(int argc,char* argv[]){

    arg_data ad(argc,argv,pinfo);

    if((ad.argc==1) or
       ((ad.argc==2) and ((ad.argstr[1] == "-h") or (ad.argstr[1] == "-help") or
                          (ad.argstr[1] == "--help") or (ad.argstr[1] == "-")))) pinfo.usage();

    blt_options client_opt;

    bool is_min_qscore_set(false);
    bool is_min_sascore_set(false);
    bool is_min_pascore_set(false);
    bool is_bacon_call_thresh(false);
    bool is_bacon_second_call_thresh(false);
    bool is_bacon_het_snp_ratio_thresh(false);

    for(int i(0);i<ad.argc;++i){
        if(ad.argmark[i]) continue;

        if(ad.argstr[i]=="-lsnp-alpha"){
            set_xrange_arg(i,ad,client_opt.is_lsnp,client_opt.lsnp_alpha);
        } else if(ad.argstr[i]=="-bsnp-diploid"){
            set_xrange_arg(i,ad,client_opt.is_bsnp_diploid,client_opt.bsnp_diploid_theta);
        } else if(ad.argstr[i]=="-bsnp-monoploid"){
            set_xrange_arg(i,ad,client_opt.is_bsnp_monoploid,client_opt.bsnp_monoploid_theta);
        } else if(ad.argstr[i]=="-bsnp-nploid"){
            set_nploid_arg(i,ad,client_opt.is_bsnp_nploid,client_opt.bsnp_nploid_ploidy,client_opt.bsnp_nploid_snp_prob);
        } else if(ad.argstr[i]=="-bsnp-diploid-file"){
            set_filename_arg(i,ad,client_opt.is_bsnp_diploid_file,client_opt.bsnp_diploid_filename);
        } else if(ad.argstr[i]=="-bsnp-diploid-allele-file"){
            set_filename_arg(i,ad,client_opt.is_bsnp_diploid_allele_file,client_opt.bsnp_diploid_allele_filename);
        } else if(ad.argstr[i]=="-anom-distro-table-alpha"){
            set_xrange_arg(i,ad,client_opt.is_adis_table,client_opt.adis_table_alpha);
        } else if(ad.argstr[i]=="-anom-distro-lrt-alpha"){
            set_xrange_arg(i,ad,client_opt.is_adis_lrt,client_opt.adis_lrt_alpha);
        } else if(ad.argstr[i]=="-anom-distro-window-lrt-alpha"){
            set_xrange_win_arg(i,ad,client_opt.is_adis_win_lrt,client_opt.adis_win_lrt_alpha,client_opt.adis_win_lrt_flank_size);
        } else if(ad.argstr[i]=="-anom-cov-alpha"){
            set_xrange_arg(i,ad,client_opt.is_acov,client_opt.acov_alpha);
        } else if(ad.argstr[i]=="-filter-anom"){
            client_opt.is_filter_anom=true;
        } else if(ad.argstr[i]=="-print-evidence"){
            client_opt.is_print_evidence=true;
        } else if(ad.argstr[i]=="-print-all-site-evidence"){
            client_opt.is_print_all_site_evidence=true;
        } else if(ad.argstr[i]=="-min-qscore"){
            set_arg(i,ad,is_min_qscore_set,client_opt.min_qscore);
        } else if(ad.argstr[i]=="-min-window-qscore"){
            set_win_arg(i,ad,client_opt.is_min_win_qscore,client_opt.min_win_qscore,client_opt.min_win_qscore_flank_size);
        } else if(ad.argstr[i]=="-max-window-mismatch"){
            int max_win_mismatch_tmp;
            set_win_arg(i,ad,client_opt.is_max_win_mismatch,max_win_mismatch_tmp,client_opt.max_win_mismatch_flank_size);
            if(max_win_mismatch_tmp<0){
                pinfo.usage("first argument following -max-window-mismatch must be a non-negative integer\n");
            }
            client_opt.max_win_mismatch=max_win_mismatch_tmp;
        } else if(ad.argstr[i]=="-min-single-align-score"){
            set_arg(i,ad,is_min_sascore_set,client_opt.min_single_align_score);
        } else if(ad.argstr[i]=="-single-align-score-exclude-mode"){
            client_opt.single_align_score_exclude_mode=true;
        } else if(ad.argstr[i]=="-single-align-score-rescue-mode"){
            client_opt.single_align_score_rescue_mode=true;
        } else if(ad.argstr[i]=="-min-paired-align-score"){
            set_arg(i,ad,is_min_pascore_set,client_opt.min_paired_align_score);
        } else if(ad.argstr[i]=="-counts"){
            set_filename_arg(i,ad,client_opt.is_counts,client_opt.counts_filename);
        } else if(ad.argstr[i]=="-bacon-snp"){
            set_filename_arg(i,ad,client_opt.is_bacon_snp,client_opt.bacon_snp_filename);
        } else if(ad.argstr[i]=="-bacon-allele"){
            set_filename_arg(i,ad,client_opt.is_bacon_allele,client_opt.bacon_allele_filename);
        } else if(ad.argstr[i]=="-bacon-allele-print-empty"){
            client_opt.is_bacon_allele_print_empty=true;
        } else if(ad.argstr[i]=="-bacon-call-thresh"){
            set_xrange_arg(i,ad,is_bacon_call_thresh,client_opt.bacon_call_thresh,true,true);
        } else if(ad.argstr[i]=="-bacon-second-call-thresh"){
            set_xrange_arg(i,ad,is_bacon_second_call_thresh,client_opt.bacon_second_call_thresh,true,true);
        } else if(ad.argstr[i]=="-bacon-het-snp-ratio-thresh"){
            set_xrange_arg(i,ad,is_bacon_het_snp_ratio_thresh,client_opt.bacon_het_snp_ratio_thresh,true,true);
        } else if(ad.argstr[i]=="-read-sample-rate"){
            set_xrange_arg(i,ad,client_opt.is_read_sample,client_opt.read_sample_rate);
        } else if(ad.argstr[i]=="-clobber"){
            client_opt.is_clobber = true;
        } else if(ad.argstr[i]=="-sorted"){
            bool is_sorted(false);
            std::string sorted_filename;
            set_filename_arg(i,ad,is_sorted,sorted_filename);
            client_opt.sorted_filenames.push_back(sorted_filename);
        } else if(ad.argstr[i]=="-reference"){
            set_filename_arg(i,ad,client_opt.is_ref_set,client_opt.ref_seq_file);
        } else if(ad.argstr[i]=="-report-range-begin"){
            set_arg(i,ad,client_opt.report_range.is_begin_pos,client_opt.report_range.begin_pos);
        } else if(ad.argstr[i]=="-report-range-end"){
            set_arg(i,ad,client_opt.report_range.is_end_pos,client_opt.report_range.end_pos);
        } else if(ad.argstr[i]=="-report-range-reference"){
            client_opt.is_report_range_ref=true;
        } else if(ad.argstr[i]=="-h"){
            pinfo.usage();
        } else if(ad.argstr[i]=="-doc"){
            pinfo.doc();
        } else { continue; }

        ad.argmark[i] = true;
    }

    ad.finalize_args();

    // sanity check arguments:
    //
    if(client_opt.sorted_filenames.empty()) pinfo.usage("no sorted file specified");

    { // check that stdin is given no more than once:
        const unsigned n_sorted(client_opt.sorted_filenames.size());
        bool is_stdin(false);
        for(unsigned i(0);i<n_sorted;++i){
            if(client_opt.sorted_filenames[i] == STDIN_FILENAME) {
                if(is_stdin) {
                    std::ostringstream oss;
                    oss << '\'' << STDIN_FILENAME << "\' (stdin) cannot be given as a -sorted argument multiple times";
                    pinfo.usage(oss.str().c_str());
                }
                is_stdin=true;
            }
        }
    }

    if(not is_bacon_second_call_thresh) client_opt.bacon_second_call_thresh=client_opt.bacon_call_thresh;

    validate_blt_opt(pinfo,client_opt,
                     is_bacon_call_thresh,is_bacon_second_call_thresh,
                     is_bacon_het_snp_ratio_thresh);

    // done sanity checking arguments
    //

    // post-check arg manipulation: (get rid of this...)
    //
    if(client_opt.report_range.is_begin_pos){
        client_opt.report_range.begin_pos -= 1;
    }

    // actual blt-ing:
    //
    blt_run(client_opt,ad.cmdline.c_str());
}



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

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



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

    std::ios_base::sync_with_stdio(false);

    // last chance to catch exceptions...
    //
    try{
        try_main(argc,argv);

    } catch (const blt_exception& e) {
        log_os << "FATAL_ERROR: " << pinfo.name() << " EXCEPTION: " << e.what() << "\n"
               << "...caught in main()\n";
        dump_cl(argc,argv,log_os);
        exit(EXIT_FAILURE);
    } catch (const casava::common::ExceptionData &e) {
        log_os << "FATAL_ERROR: " << pinfo.name() << " EXCEPTION: " 
               << e.getContext() << ": " << e.getMessage() << "\n"
               << "...caught in main()\n";
        dump_cl(argc,argv,log_os);
        exit (EXIT_FAILURE);
    } catch(const std::exception& e) {
        log_os << "FATAL_ERROR: EXCEPTION: " << e.what() << "\n"
               << "...caught in main()\n";
        dump_cl(argc,argv,log_os);
        exit(EXIT_FAILURE);
    } catch(...) {
        log_os << "FATAL_ERROR: UNKNOWN EXCEPTION\n"
               << "...caught in main()\n";
        dump_cl(argc,argv,log_os);
        exit(EXIT_FAILURE);
    }
    return EXIT_SUCCESS;
}