#ifndef SEQAN_UTILS_HPP
#define SEQAN_UTILS_HPP

#include <vector>
#include<seqan/seq_io.h>
#include<seqan/misc/interval_tree.h>
#include<seqan/find.h>

namespace neusomatic{ namespace bio{

template<typename Base>
std::string Base2String(const Base& base, const std::string& gap_symbol){

    //std::cout<<static_cast<unsigned char>(base)<<" :static cast: ";
    //std::cout<<(unsigned)seqan::ordValue(base)<<std::endl;
    
    switch((unsigned)seqan::ordValue(base))
    {
        case 0: return "A";
        case 1: return "C";
        case 2: return "G";
        case 3: return "T";
        default: return gap_symbol;
    }
    //should never reach here
    return "";

}

template<>
std::string Base2String<char>(const char& base, const std::string& gap_symbol) {
  switch(base) {
    case 'a':
    case 'A': 
    case 0:
      return "A";

    case 'c':
    case 'C':
    case 1:
      return "C";

    case 'g':
    case 'G':
    case 2:
      return "G";
    case 't':
    case 'T':
    case 3:
      return "T";
    default:
      return gap_symbol;
  }
}

template<typename Itr>
std::string to_string(Itr b, Itr e, const std::string& gap_symbol = "N"){
  std::string result;
  auto it = b;
  for(; it < e; ++it){
    result += Base2String(*it, gap_symbol);
  }
  return result;
}

inline std::string to_string(const seqan::Dna5String& seq, const std::string& gap_symbol = "N"){
  std::string result;
  for (unsigned int i = 0; i < seqan::length(seq); ++i) {
     result += Base2String(seq[i], gap_symbol); 
  }
  return result;
}

template<typename TInterval>
inline decltype(auto) ToSeqanIntervals(const std::vector<TInterval>& invs){ 

  typedef seqan::IntervalAndCargo<int, TInterval> TIntervalAndCargo;
  std::vector<TIntervalAndCargo> seqan_intervals; 
  for (auto it = invs.cbegin(); it != invs.cend(); ++it) {
    TIntervalAndCargo i(it->left(), it->right(), *it);
    seqan_intervals.push_back(i);
  }
  return seqan_intervals;
}

inline std::vector<seqan::CharString> SeqanSplit(seqan::CharString target, std::string splitter) {
  /*
    Return a vec of size 1 containing the intact target if splitter is not found in the target. 
  */
  if (seqan::length(target) == 0 || seqan::length(splitter) == 0) {
    throw std::runtime_error("Invalid string and pattern to split.");
  }
  using TPos = typename seqan::Position<seqan::CharString>::Type;

  std::vector<seqan::CharString> result;
  seqan::Finder<seqan::CharString> finder(target);
  seqan::Pattern<seqan::CharString, seqan::Horspool> pattern(splitter);
  std::vector<std::pair<TPos, TPos>> searches;
  while (seqan::find(finder, pattern)) {
    searches.emplace_back(seqan::beginPosition(finder), seqan::endPosition(finder));
  }

  TPos lastp = 0;
  for (auto const& p: searches) {
    seqan::CharString unit = seqan::infix(target, lastp, p.first);
    if (!seqan::empty(unit)) result.push_back(unit);
    lastp = p.second;
  }
  if (lastp < seqan::length(target) - 1) {
    seqan::CharString unit = seqan::infix(target, lastp, seqan::length(target));
    result.push_back(unit);
  }
  return result;
}

}// namespace neusomatic
}// namespace bio

#endif /* SEQAN_UTILS_HPP */