// -*- 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
///
/// note coding convention for all ranges '_pos fields' is:
/// XXX_begin_pos is zero-indexed position at the begining of the range
/// XXX_end_pos is zero-index position 1 step after the end of the range
///

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

#include "starling/starling_info.hh"
#include "starling/starling_run.hh"
#include "starling/starling_shared.hh"

#include <cassert>
#include <cstdlib>

#include <fstream>
#include <sstream>



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



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

    arg_data ad(argc,argv,pinfo);

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

    initialize_blt_signals(pinfo.name(),ad.cmdline.c_str());

    starling_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);
    bool is_contigs_set(false);
    bool is_contig_reads_set(false);

    bool is_bsnp_ssd_no_mismatch(false);
    bool is_bsnp_ssd_one_mismatch(false);

    bool is_min_can_indel_set(false);    
    bool is_min_can_indel_frac_set(false);
    bool is_min_small_can_indel_frac_set(false);
    bool is_max_can_indel_density_set(false);

    bool is_max_basecall_filter_fraction(false);

    bool is_max_vexp_iterations(false);

    bool is_max_indel_size(false);

    for(int i(0);i<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-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]=="-bsnp-monoploid"){
            set_xrange_arg(i,ad,client_opt.is_bsnp_monoploid,client_opt.bsnp_monoploid_theta);
        } else if(ad.argstr[i]=="-bsnp-ssd-no-mismatch"){
            set_xrange_arg(i,ad,is_bsnp_ssd_no_mismatch,client_opt.bsnp_ssd_no_mismatch,true);
        } else if(ad.argstr[i]=="-bsnp-ssd-one-mismatch"){
            set_xrange_arg(i,ad,is_bsnp_ssd_one_mismatch,client_opt.bsnp_ssd_one_mismatch,true);
        } 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]=="-bindel-diploid"){
            set_xrange_arg(i,ad,client_opt.is_bindel_diploid,client_opt.bindel_diploid_theta);
        } else if(ad.argstr[i]=="-bindel-diploid-file"){
            set_filename_arg(i,ad,client_opt.is_bindel_diploid_file,client_opt.bindel_diploid_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-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]=="-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]=="-min-paired-align-score"){
            set_arg(i,ad,is_min_pascore_set,client_opt.min_paired_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]=="-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]=="-clobber"){
            client_opt.is_clobber = true;
        } else if(ad.argstr[i]=="-sorted"){
            bool is_sorted(not client_opt.sorted_filenames.empty());
            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]=="-bam-file"){
            bool is_bam_filename(not client_opt.bam_filename.empty());
            set_filename_arg(i,ad,is_bam_filename,client_opt.bam_filename);
        } else if(ad.argstr[i]=="-bam-seq-name"){
            bool is_bam_seq_name(not client_opt.bam_seq_name.empty());
            set_filename_arg(i,ad,is_bam_seq_name,client_opt.bam_seq_name);
        } else if(ad.argstr[i]=="-single-seq-reference"){
            set_filename_arg(i,ad,client_opt.is_ref_set,client_opt.ref_seq_file);
        } else if(ad.argstr[i]=="-indel-contigs"){
            client_opt.is_test_indels=true;
            set_filename_arg(i,ad,is_contigs_set,client_opt.indel_contig_filename);
        } else if(ad.argstr[i]=="-indel-contig-reads"){
            client_opt.is_test_indels=true;
            set_filename_arg(i,ad,is_contig_reads_set,client_opt.indel_contig_read_filename);
        } else if(ad.argstr[i]=="-indel-error-rate"){
            client_opt.is_test_indels=true;
            set_xrange_arg(i,ad,client_opt.is_simple_indel_error,client_opt.simple_indel_error,true);
        } 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]=="-genome-size"){
            set_arg(i,ad,client_opt.is_genome_size,client_opt.genome_size);
        } else if(ad.argstr[i]=="-print-all-poly-gt"){
            client_opt.is_print_all_poly_gt=true;
        } else if(ad.argstr[i]=="-print-used-allele-counts"){
            client_opt.is_print_used_allele_counts=true;
        } else if(ad.argstr[i]=="-min-candidate-indel-reads"){
            set_arg(i,ad,is_min_can_indel_set,client_opt.min_candidate_indel_reads);
        } else if(ad.argstr[i]=="-min-candidate-indel-read-frac"){
            set_xrange_arg(i,ad,is_min_can_indel_frac_set,client_opt.min_candidate_indel_read_frac,true);
        } else if(ad.argstr[i]=="-min-small-candidate-indel-read-frac"){
            set_xrange_arg(i,ad,is_min_small_can_indel_frac_set,client_opt.min_small_candidate_indel_read_frac,true);
        } else if(ad.argstr[i]=="-max-candidate-indel-density"){
            set_xrange_arg(i,ad,is_max_can_indel_density_set,client_opt.max_candidate_indel_density,false,true);
        } else if(ad.argstr[i]=="-realigned-read-file"){
            set_filename_arg(i,ad,client_opt.is_realigned_read_file,client_opt.realigned_read_filename);
        } else if(ad.argstr[i]=="-realign-submapped-reads"){
            client_opt.is_realign_submapped_reads=true;
        } else if(ad.argstr[i]=="-snp-max-basecall-filter-fraction"){
            set_xrange_arg(i,ad,is_max_basecall_filter_fraction,client_opt.max_basecall_filter_fraction,true);
        } else if(ad.argstr[i]=="-max-vexp-iterations"){
            set_arg(i,ad,is_max_vexp_iterations,client_opt.max_vexp_iterations);
        } else if(ad.argstr[i]=="-min-vexp"){
            set_xrange_arg(i,ad,client_opt.is_min_vexp,client_opt.min_vexp,true);
        } else if(ad.argstr[i]=="-no-ambiguous-path-clip"){
            client_opt.is_clip_ambiguous_path=false;
        } else if(ad.argstr[i]=="-max-indel-size") {
            set_arg(i,ad,is_max_indel_size,client_opt.max_indel_size);
        } else if(ad.argstr[i]=="-filter-unanchored") {
            client_opt.is_filter_unanchored = true;
        } else if(ad.argstr[i]=="-include-singleton") {
            client_opt.is_include_singleton = true;
        } else if(ad.argstr[i]=="-include-anomalous") {
            client_opt.is_include_anomalous = true;
        } else if(ad.argstr[i]=="-all-warnings"){
            client_opt.verbosity=LOG_LEVEL::ALLWARN;
        } else if(ad.argstr[i]=="-skip-variable-metadata"){
            client_opt.is_write_variable_metadata=false;
        } 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 argument settings:
    //
    {
        // sanity check input read info:

        if(client_opt.sorted_filenames.empty() and client_opt.bam_filename.empty()) {
            pinfo.usage("no reads file specified");
        }
        if(not client_opt.sorted_filenames.empty()){
            const unsigned n_sorted(client_opt.sorted_filenames.size());
            if((n_sorted!=1) or (not client_opt.bam_filename.empty())){
                pinfo.usage("cannot specify multiple reads files");
            }
        }

        if((not client_opt.bam_filename.empty()) and client_opt.bam_seq_name.empty()) {
            pinfo.usage("must specify -bam-seq-name when a bam file is provided");
        }
    }

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

    client_opt.is_call_indels=(client_opt.is_bindel_diploid);

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

    // max_theta for indels is actually 2./3., but because we don't
    // allow non-reference hets, we stick with the lower value
    // used for snps:
    //
    if(client_opt.bindel_diploid_theta>MAX_DIPLOID_THETA){
        std::ostringstream oss;
        oss << "indel diploid heterozygosity exceeds maximum value of: " << MAX_DIPLOID_THETA;
        pinfo.usage(oss.str().c_str());
    }

    if(not client_opt.is_ref_set){
        pinfo.usage("a reference sequence must be specified");
    }

    if(client_opt.is_genome_size and (client_opt.genome_size<1) ) {
        pinfo.usage("genome-size must be greater than 0");
    }
    //
    // done sanity checking arguments
    //

    if(client_opt.report_range.is_begin_pos){
        client_opt.report_range.begin_pos -= 1;
    }

    starling_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;
}