// -*- 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_common/blt_streams.hh>
#include <blt_util/digt.hh>

#include <ctime>

#include <fstream>
#include <iostream>
#include <sstream>



static
void
open_ofstream(const prog_info& pinfo,
              const std::string& filename,
              const char* label,
              const bool is_clobber,
              std::ofstream& fos) {

    std::ifstream tis(filename.c_str());
    if(tis and not is_clobber) {
        std::ostringstream oss;
        oss << label << " file already exists: " << filename;
        pinfo.usage(oss.str().c_str());
    }

    fos.open(filename.c_str());
    if(!fos) {
        std::ostringstream oss;
        oss << label << " file can't be opened: " << filename;
        pinfo.usage(oss.str().c_str());
    }
}



static
void
write_audit(const blt_options& opt,
            const prog_info& pinfo,
            const char* const cmdline,
            std::ostream& os,
            const char* const prefix = 0){


    if(opt.is_write_variable_metadata){
        if(prefix) os << prefix;
        os << "CMDLINE " << cmdline << "\n";
    }
    if(prefix) os << prefix;
    os << "PROGRAM_VERSION " << pinfo.version() << "\n";
    if(opt.is_write_variable_metadata){
        if(prefix) os << prefix;
        const time_t result(time(0));
        os << "START_TIME " << asctime(localtime(&result));
    }
}



static
void
write_file_audit(const blt_options& opt,
                 const prog_info& pinfo,
                 const char* const cmdline,
                 std::ostream& os) {

    write_audit(opt,pinfo,cmdline,os,"#$ ");
    os << "#\n";
}



static
void
setup_bsnp_file(const blt_options& client_opt,
                const prog_info& pinfo,
                const char* const cmdline,
                std::auto_ptr<std::ostream>& apo,
                const std::string& filename,
                const char* label,
                const bool is_include_seq_name) {

    std::ofstream* fosptr(new std::ofstream);
    apo.reset(fosptr);
    std::ofstream& fos(*fosptr);
    open_ofstream(pinfo,filename,label,client_opt.is_clobber,fos);

    fos << "# ** " << pinfo.name() << " " << label << " file **\n";
    write_file_audit(client_opt,pinfo,cmdline,fos);
    fos << "#$ SNP_THETA " << client_opt.bsnp_diploid_theta << "\n";
    fos << "#\n";
    fos << "#$ COLUMNS ";
    if(is_include_seq_name) { fos << "seq_name "; }
    fos << "pos bcalls_used bcalls_filt ref Q(snp) max_gt Q(max_gt) max_gt|poly_site Q(max_gt|poly_site)";

    if(client_opt.is_print_used_allele_counts) {
        for(unsigned b(0);b<N_BASE;++b){
            fos << " " << id_to_base(b) << "_used";
        }
    }
    
    if(client_opt.is_print_all_poly_gt) {
        for(unsigned gt(0);gt<DIGT::SIZE;++gt){
            fos << " P(" << DIGT::label(gt) << "|ps)";
        }
    }

    fos << "\n";
}



void
blt_streams::
write_file_audit(const blt_options& opt,
                 const prog_info& pinfo,
                 const char* const cmdline,
                 std::ostream& os) const {

    ::write_file_audit(opt,pinfo,cmdline,os);
}



void
blt_streams::
open_ofstream(const prog_info& pinfo,
              const std::string& filename,
              const char* label,
              const bool is_clobber,
              std::ofstream& fos) const {

    ::open_ofstream(pinfo,filename,label,is_clobber,fos);
}



blt_streams::
blt_streams(const blt_options& client_opt,
            const prog_info& pinfo,
            const char* const cmdline,
            const bool is_include_seq_name)
    : _report_os(std::cout) {
 
    write_audit(client_opt,pinfo,cmdline,report_os());

    if(client_opt.is_counts) {
        std::ofstream* fosptr(new std::ofstream);
        _counts_osptr.reset(fosptr);
        std::ofstream& fos(*fosptr);
        open_ofstream(pinfo,client_opt.counts_filename,"counts",client_opt.is_clobber,fos);


        fos << "# ** " << pinfo.name() << " counts file **\n";
        write_file_audit(client_opt,pinfo,cmdline,fos);
        fos << "#$ COLUMNS pos A_used C_used G_used T_used unused\n";
    }

    if(client_opt.is_bacon_allele) {
        std::ofstream* fosptr(new std::ofstream);
        _bacon_allele_osptr.reset(fosptr);
        std::ofstream& fos(*fosptr);
        open_ofstream(pinfo,client_opt.bacon_allele_filename,"bacon allele",client_opt.is_clobber,fos);

        fos << "# ** " << pinfo.name() << " BaCON allele file **\n";
        write_file_audit(client_opt,pinfo,cmdline,fos);
        fos << "#$ COLUMNS pos A_used C_used G_used T_used allele_call bcalls bcalls_used BaCON_score\n";
    }

    if(client_opt.is_bacon_snp) {
        std::ofstream* fosptr(new std::ofstream);
        _bacon_snp_osptr.reset(fosptr);
        std::ofstream& fos(*fosptr);
        open_ofstream(pinfo,client_opt.bacon_snp_filename,"bacon snp",client_opt.is_clobber,fos);

        fos << "# ** " << pinfo.name() << " BaCON snp file **\n";
        write_file_audit(client_opt,pinfo,cmdline,fos);
        fos << "#$ COLUMNS pos A_used C_used G_used T_used snp_call bcalls bcalls_used BaCON_score ref snp_type\n";
    }

    if(client_opt.is_bsnp_diploid_file){
        setup_bsnp_file(client_opt,pinfo,cmdline,_bsnp_diploid_osptr,
                        client_opt.bsnp_diploid_filename,"bsnp-diploid",is_include_seq_name);          
    }

    if(client_opt.is_bsnp_diploid_allele_file){
        setup_bsnp_file(client_opt,pinfo,cmdline,_bsnp_diploid_allele_osptr,
                        client_opt.bsnp_diploid_allele_filename,"bsnp-diploid sites",is_include_seq_name);
    }
}



// this should remain in the cpp so that auto_ptr works correctly
blt_streams::
~blt_streams() { }