// -*- 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_util/log.hh"
#include "blt_util/seq_util.hh"

#include <cassert>
#include <cstdlib>

#include <fstream>
#include <iostream>



void
base_error(const char* func, const char a){
    log_os << "ERROR:: Invalid base in " << func << ".\n"
           << "\t\tinvalid base (char): '" << a << "'\n"
           << "\t\tinvalid base (int): " << static_cast<int>(a) << "\n";
    exit(EXIT_FAILURE);
}



void
id_to_base_error(const uint8_t i){
    log_os << "ERROR:: Invalid id in id_to_base. id: " << i << "\n";
    exit(EXIT_FAILURE);
}



bool
is_valid_seq(const char* seq){

    assert(NULL != seq);

    while(*seq !=  '\0'){
        if(not is_valid_base(*seq)) return false;
        seq++;
    }
    return true;
}



void
get_ref_seq(const char* ref_seq_file,
            std::string& ref_seq) {

    static const unsigned buff_size(50000);
    char buff[buff_size];

    std::ifstream ref_is(ref_seq_file);

    if( ! ref_is ) {
        log_os << "ERROR:: Can't open reference sequence file: " << ref_seq_file << "\n";
        exit(EXIT_FAILURE);
    }

#ifdef SEQ_UTIL_VERBOSE
    log_os << "Reading from reference sequence file " << ref_seq_file << "\n";
#endif
    ref_is.getline(buff,buff_size);
#ifdef SEQ_UTIL_VERBOSE
    log_os << "First line: " << buff << "\n";
#endif

    ref_seq.clear();
    while(true){
        ref_is.getline(buff,buff_size);
        if(! ref_is) {
            if     (ref_is.eof()) break;
            else if(ref_is.fail()) {
                if(ref_is.bad()){
                    log_os << "ERROR:: unexpected failure while attempting to read sequence file: " << ref_seq_file << "\n";
                    exit(EXIT_FAILURE);
                }
                ref_is.clear();
            }
        }
        ref_seq += buff;
    }

#ifdef SEQ_UTIL_VERBOSE
    log_os << "Finished reading from reference sequence file " << ref_seq_file << "\n";
    log_os << "Reference sequence size: " << ref_seq.size() << "\n";
#endif
}



void
standardize_ref_seq(const char* ref_seq_file,
                    std::string& ref_seq) {

    const std::string::size_type ref_size(ref_seq.size());
    for(std::string::size_type i(0);i<ref_size;++i){
        const char old_ref(ref_seq[i]);
        char c(old_ref);
        if(islower(c)) c = toupper(c);
        if(not is_valid_base(c)){
            if(not is_iupac_base(c)) {
                log_os << "ERROR:: Unexpected character in reference sequence.\n";
                log_os << "\treference-sequence: " << ref_seq_file << "\n";
                log_os << "\tcharacter: '" << old_ref << "'\n";
                log_os << "\tcharacter-position: " << (i+1) << "\n";
                exit(EXIT_FAILURE);
            }
            c=elandize_base(c);
        }
        if(c != old_ref) ref_seq[i] = c;
    }
}



std::size_t
get_ref_seq_known_size(const std::string& ref_seq) {
    std::string::const_iterator i(ref_seq.begin());
    const std::string::const_iterator i_end(ref_seq.end());
    std::size_t size(0);
    for(;i != i_end;++i){
        if(*i != 'N') size++;
    }
    return size;
}



void
get_seq_repeat_unit(const std::string& seq,
                    std::string& repeat_unit,
                    unsigned& repeat_count) {

    const unsigned seq_size(seq.size());

    // check all divisors of seq_size until a repeat is found:
    for(unsigned i(1);i<seq_size;++i){
         /// TODO -- find a real way to get the divisor list, this
         /// isn't very important because indels are so small it
         /// almost doesn't matter.
        if((seq_size%i) != 0) continue;

        bool is_repeat(true);
        for(unsigned j(i);j<seq_size; j += i){
            for(unsigned k(0);k<i;++k){
                if(seq[j+k] != seq[k]) {
                    is_repeat=false;
                    break;
                }
            }
            if(not is_repeat) break;
        }
        if(is_repeat) {
            repeat_unit = seq.substr(0,i);
            repeat_count = seq_size/i;
            return;
        }
    }

    repeat_unit = seq;
    repeat_count = 1;
}