/*****************************************************************************/
// Copyright (c) Illumina 2008
// Author: Richard Shaw
//
// 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).
/*****************************************************************************/

#include <boost/format.hpp>

#include "statistics/Basic_Stats.h"

/*****************************************************************************/

Basic_Stats::Basic_Stats()
{
    ;
}

/*****************************************************************************/

Basic_Stats::~Basic_Stats()
{
    ;
}

/*****************************************************************************/

bool Basic_Stats::derive(Base_Calls<unsigned int>& base_calls)
{
    const unsigned int num_cycles(base_calls.size(Uint_Base_Calls::DIM_CYCLE));

    my_pc_err_vec.resize(num_cycles);
    my_pc_blank_vec.resize(num_cycles);

    Cycle_Float_Vec_Iter pc_err_iter(my_pc_err_vec.begin());
    Cycle_Float_Vec_Iter pc_blank_iter(my_pc_blank_vec.begin());

    const Base_Calls<unsigned int>::List base_calls_list
        = base_calls.get_cycle_base_calls_list();

    for (Uint_Base_Calls::List::const_iterator
             base_calls_citer(base_calls_list.begin());
         base_calls_citer != base_calls_list.end();
         ++base_calls_citer, ++pc_err_iter, ++pc_blank_iter) {
        const unsigned int
            num_bases(base_calls_citer->read_count(Uint_Base_Calls::READ_ANY));
        const unsigned int
            num_err(base_calls_citer->read_count(Uint_Base_Calls::READ_ERR));
        const unsigned int
            num_blank(base_calls_citer->
                      read_count(Uint_Base_Calls::READ_BLANK));
        const unsigned int num_non_blank(num_bases - num_blank);

        *pc_err_iter = ((num_non_blank != 0)
                        ? ((100.0 * num_err) / num_non_blank)
                        : 0.0);
        *pc_blank_iter = ((num_bases != 0)
                          ? ((100.0 * num_blank) / num_bases)
                          : 0.0);
    }

    return true;
}

/*****************************************************************************/

std::ostream& operator<<(std::ostream& ostrm,
                         const Basic_Stats& basic_stats)
{
    typedef std::vector<float> Cycle_Float_Vec;
    typedef Cycle_Float_Vec::const_iterator Cycle_Float_Vec_CIter;

    ostrm << "Cycle:\tErr pc:\tBlank pc:" << std::endl;

    unsigned int cycle_num(1);
    Cycle_Float_Vec_CIter pc_err_citer(basic_stats.my_pc_err_vec.begin());
    Cycle_Float_Vec_CIter pc_blank_citer(basic_stats.my_pc_blank_vec.begin());

    const unsigned int num_dec_places(2);
    const unsigned int num_pre_pt_places(2);
    const unsigned int width(num_pre_pt_places + 1 + num_dec_places);
    ostrm << std::fixed << std::setprecision(num_dec_places);

    for ( ; pc_err_citer != basic_stats.my_pc_err_vec.end();
          ++cycle_num, ++pc_err_citer, ++pc_blank_citer) {
        ostrm << cycle_num
              << "\t" << std::setw(width) << *pc_err_citer
              << "\t" << std::setw(width) << *pc_blank_citer
              << std::endl;
    }

    return ostrm;
}

/*****************************************************************************/