// validate argument count

if( argc != 2 ) {

cerr << "USAGE: " << argv[0] << " <input BAM file> " << endl;

return EXIT_FAILURE;

}

string filename = argv[1];

//cerr << "Printing alignments from file: " << filename << endl;

BamReader reader;

if (!reader.Open(filename)) {

cerr << "could not open filename " << filename << endl;

return EXIT_FAILURE;

}

cerr << filename << ": Done opening" << endl;

// Header can't be used to accurately determine sort order because samtools never

// changes it; instead, check after loading each read as is done with "samtools index"

// We don't need to load an index (right?)

// if (!reader.LocateIndex()) {

// const string index_filename = filename + ".bai";

// if (!reader.OpenIndex(index_filename)) {

// cerr << "could not open index" << endl;

// }

// }

const SamHeader header = reader.GetHeader();

cerr << filename << ": Done getting header" << endl;

const RefVector refs = reader.GetReferenceData();

cerr << filename << ": Done getting reference data" << endl;

BamWriter writer;

if (! output_bam_filename.empty()) {

if (! writer.Open(output_bam_filename, header, refs)) {

cerr << "Could not open BAM output file " << output_bam_filename << endl;

return EXIT_FAILURE;

}

cerr << filename << ": Done opening BAM output file " << output_bam_filename << endl;

}

alignmentMap read1Map; // a single map, for all reads awaiting their mate

typedef map<string,int32_t> stringMap;

typedef stringMap::iterator stringMapI;

stringMap ref_mates;

// alignmentMap read1Map, read2Map;

BamAlignment full_al;

int32_t count = 0;

uint32_t max_reads_in_map = 0;

int32_t n_reads_skipped_unmapped = 0;

int32_t n_reads_skipped_mate_unmapped = 0;

int32_t n_reads_skipped_wont_see_mate = 0;

int32_t n_reads_skipped_mate_tail_est = 0;

int32_t n_reads_skipped_ref_mate = 0;

int32_t n_reads = 0;

int32_t n_singleton_reads = 0;

int32_t last_RefID = -1;

int32_t last_Position = -1;

cerr << filename << ": Looking for up to " << pairs_to_process << " link pairs,"

<< " total tail = " << link_pair_total_tail

<< " critical tail = " << link_pair_crit_tail

<< ", must be on diff chromosome = " << link_pair_diff_chrom << endl;

while (reader.GetNextAlignment(full_al)

&& (! pairs_to_process || count < pairs_to_process)) {

BamAlignment al = full_al;

//printAlignmentInfo(al, refs);

//++count;

++n_reads;

if (last_RefID < 0) last_RefID = al.RefID;

if (last_Position < 0) last_Position = al.Position;

if (al.RefID > last_RefID) {

// We've moved to the next reference sequence

// Clean up reads with mates expected here that haven't been seen

if (debug_ref_mate) {

cerr << "MISSED " << ref_mates.size() << " ref_mates on this reference "

<< last_RefID << " " << refs[last_RefID].RefName << endl;

}

for (stringMapI rmI = ref_mates.begin(); rmI != ref_mates.end(); ++rmI) {

++n_reads_skipped_ref_mate;

read1Map.erase(read1Map.find(rmI->first));

ref_mates.erase(ref_mates.find(rmI->first));

}

last_RefID = al.RefID;

last_Position = al.Position;

} else if (! isCoordinateSorted(al.RefID, al.Position, last_RefID, last_Position)) {

cerr << filename << " is not sorted, " << al.Name << " out of position" << endl;

return EXIT_FAILURE;

}

if (! al.IsMapped()) { ++n_reads_skipped_unmapped; continue; }

if (! al.IsMateMapped()) { ++n_reads_skipped_mate_unmapped; continue; }

alignmentMapI mI = read1Map.find(al.Name);

if (mI == read1Map.end()) {

// the read name has not been seen before

if (al.MateRefID < al.RefID

|| (al.MateRefID == al.RefID && al.MatePosition < al.Position)) {

// we should have seen its mate earlier, so skip it

++n_reads_skipped_wont_see_mate;

continue;

}

// If the mate likely to also be a link pair candidate, add the read

int32_t mate_tail_est = readTailS(al.IsMateMapped(), al.IsMateReverseStrand(),

al.MatePosition, refs[al.MateRefID].RefLength, max_read_length);

if (mate_tail_est <= mate_tail_est_crit) {

// the mate tail estimate suggests it might be a link pair candidate

read1Map[al.Name] = al; // add the read to the map

} else {

// the mate tail estimate appears too long for the mate to be a candidate

++n_reads_skipped_mate_tail_est;

continue;

}

if (read1Map.size() > max_reads_in_map) max_reads_in_map = read1Map.size();

if (al.MateRefID == al.RefID && al.MatePosition >= al.Position) {

// the mate is expected later on this contig

ref_mates[al.Name] = al.MateRefID;

}

} else {

// get the mate's alignment, and process the pair

const BamAlignment& al_mate = mI->second;

if (processReadPair(al, al_mate, refs, link_pair_total_tail,

link_pair_crit_tail, link_pair_diff_chrom)) {

++count;

// write to the new BAM file, if the string is not empty

if (! output_bam_filename.empty()) {

writer.SaveAlignment(al_mate); // the first one seen

writer.SaveAlignment(al); // the second one seen

}

}

read1Map.erase(mI);

if (al.MateRefID == al.RefID) {

stringMapI rmI = ref_mates.find(al.Name);

if (rmI == ref_mates.end()) {

cerr << "expected a ref_mate, couldn't find its name: " << al.Name << endl;

return EXIT_FAILURE;

}

ref_mates.erase(rmI);

}

}

}

cerr << "===============================" << endl;

cerr << read1Map.size() << " alignments left in read1Map" << endl;

cerr << max_reads_in_map << " maximum number of reads in read1Map" << endl;

cerr << count << " pairs processed" << endl;

cerr << "===============================" << endl;

cerr << n_reads << " total reads" << endl;

cerr << n_singleton_reads << " singleton reads" << endl;

cerr << n_reads_skipped_unmapped << " reads skipped because unmapped" << endl;

cerr << n_reads_skipped_mate_unmapped << " reads skipped because mate unmapped" << endl;

cerr << n_reads_skipped_wont_see_mate << " reads skipped because mate won't be seen" << endl;

cerr << n_reads_skipped_mate_tail_est << " reads skipped because mate tail appears too long" << endl;

cerr << n_reads_skipped_ref_mate << " reads skipped because mate not on reference" << endl;

reader.Close();

if (! output_bam_filename.empty()) {

writer.Close();

}

return EXIT_SUCCESS;