// -*- 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 "starling_read_align_shared.hh"
#include "starling/starling_shared.hh"

#include <cassert>

#include <iostream>



std::ostream&
operator<<(std::ostream& os,
           const candidate_alignment& cal) {

    os << "CANDIDATE_ALIGNMENT: " << cal.al;
    os << "CANDIDATE_ALIGNMENT_LEAD: " << cal.leading_indel_key;
    os << "CANDIDATE_ALIGNMENT_TRAIL: " << cal.trailing_indel_key;

    return os;
}



// get the keys of the indels present in the candidate alignment
//
void
get_alignment_indels(const candidate_alignment& cal,
                     const unsigned max_indel_size,
                     indel_set_t& indels){

    using namespace ALIGNPATH;

    indels.clear();

    const path_t& path(cal.al.path);
    pos_t ref_head_pos(cal.al.pos);
    const std::pair<unsigned,unsigned> ends(get_nonclip_end_segments(cal.al.path));
    const unsigned as(path.size());
    for(unsigned i(0);i<as;++i){
        const path_segment& ps(path[i]);
        const bool is_edge_segment((i==ends.first) or (i==ends.second));
        if((ps.type==INSERT) or (ps.type==DELETE)) {
            if(is_edge_segment) {
                assert(ps.type==INSERT);
                if(i==ends.first){
                    assert(cal.leading_indel_key.type != INDEL::NONE);
                    indels.insert(cal.leading_indel_key);
                } else {
                    assert(cal.trailing_indel_key.type != INDEL::NONE);
                    indels.insert(cal.trailing_indel_key);
                }
            } else {
                if(ps.length <= max_indel_size){
                    const INDEL::index_t id( (ps.type==INSERT) ? INDEL::INSERT : INDEL::DELETE );
                    indels.insert(indel_key(ref_head_pos,id,ps.length));
                } else {
                    indels.insert(indel_key(ref_head_pos,INDEL::SV_BP_LEFT,ps.length));
                    const pos_t right_pos(ref_head_pos+((ps.type==INSERT) ? 0 : ps.length));
                    indels.insert(indel_key(right_pos,INDEL::SV_BP_RIGHT,ps.length));
                }
            }
        }
        if(is_segment_type_ref_length(ps.type)) ref_head_pos += ps.length;
    }
}