#ifndef SEQUENCEUTILS_HH_
#define SEQUENCEUTILS_HH_
/**
 * Project     : CASAVA
 * Module      : $RCSfile: SequenceUtils.hh,v $
 * @author     : Tony Cox
 * Copyright   : Copyright (c) Illumina 2008, 2009. All rights reserved.
 *
 ** 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 "common/Alignment.hh"
#include "common/RelOrient.hh"

#include <iomanip>
#include <sstream>

#include <boost/utility.hpp>

#include <cstring>


using namespace casava::common;

namespace casava {
namespace common {

/**
 * @class SequenceUtils
 *
 * @brief A Singleton class holding methods useful in operating on Sequence/Read
 *
 * $Header $
 */
//TODO: Refactor with Pipeline code
class SequenceUtils : private boost::noncopyable{
public:
    // compute the total read quality from its ASCII representation
    static
    int totalBaseQualityForRead(const char* readQuality) {
        int sum(0);
        const unsigned read_size(strlen(readQuality));
        for (unsigned int i(0); i<read_size; i++) {
            sum+=((int)readQuality[i])-64;
        } // ~for
        return sum;
    } // ~totalBaseQualityForRead( const char* readQuality)


    static
    std::string getSampleName(Alignment& alignment) {
        char buf[256];
        sprintf(buf, "%s %d %d", alignment.getSpot().getTile().getMachineName().c_str(), alignment.getSpot().getTile().getRunNumber(), alignment.getSpot().getTile().getLaneNumber());
        return (std::string)buf;
    } // ~getSampleName

    static
    std::string getLaneKey(const Alignment& alignment) {
        std::ostringstream ostrm;
        ostrm << alignment.getSpot().getTile().getMachineName() << "_"
            // << std::setfill('0') << std::setw(4)
              << alignment.getSpot().getTile().getRunNumber() << ":"
              << alignment.getSpot().getTile().getLaneNumber();
        return ostrm.str();
    }

    static
    std::string getReadId(const Alignment& alignment) {
        std::ostringstream ostrm;
        ostrm << getLaneKey(alignment) << ":"
              << alignment.getTileNumber() << ":"
              << alignment.getX() << ":"
              << alignment.getY();

        const std::string indexStr(alignment.getIndex());

        if (!indexStr.empty()) {
            ostrm << "#" << indexStr;
        }

        const unsigned int readNumber(alignment.getReadNumber());

        if (readNumber != 0) {
            ostrm << "/" << readNumber;
        }
        
        return ostrm.str();
    }

    static
    bool getReadPairInfo(const Alignment& alignment,
                         unsigned int readLen,
                         unsigned int partnerReadLen,
                         bool& isChimeric,
                         long& leftPos,
                         unsigned int& insertSize,
                         RelOrient& relOrient);

    static
    double convertQualToProbCorrect(int qv) {
        return 1.0/(1+std::pow(10, (-qv/10.0)));
    }

    static
    double convertPhredToProbCorrect(int qv) {
        return (1.0-std::pow(10, (-qv/10.0)));
    }

    static
    double convertLogOddsToProbError(int qv) { return 1./(1.+std::pow(10.,(static_cast<double>(qv)/10.))); }

    static
    double convertPhredToProbError(int qv) { return std::min(1.,std::pow(10.,(-static_cast<double>(qv)/10.))); }

    static
    bool
    isValidQualString(const char* qual,
                      const bool isQphred);

    static
    double
    getSemiAlignedReadMetric(const Alignment& alignment,
                             const bool isQphred);
							 
	static
	double
	getBreakPointHypothesisScore(const Alignment& alignment, const int breakPointPos,
                         const bool isQphred, const bool enteringBreakPoint);						 
							 

	static
	char comp(const char c) {
		switch (c) {
		case 'A':
			return 'T';
		case 'C':
			return 'G';
		case 'G':
			return 'C';
		case 'T':
			return 'A';
		case 'N':
			return 'N';
		}
                comp_error(c);
                return 'X';
	} // ~comp


        static
	void reverseComp(std::string& read) {
		const unsigned nr(read.size());
		const unsigned nr2(nr/2);
		for (unsigned i(0); i<(nr2); ++i) {
			const char tmp(comp(read[i]));
			read[i] = comp(read[nr-(i+1)]);
			read[nr-(i+1)] = tmp;
		}
		if (nr%2==1)
			read[nr2] = comp(read[nr2]);
	} // ~reverseComp


private:
    struct ReadScorer : private boost::noncopyable {

        /** Instance getter
         *
         */
        static const ReadScorer& get(const bool isQphred) {
            static const ReadScorer rs_phred(true);
            static const ReadScorer rs_logodds(false);
            if(isQphred) {
                return rs_phred;
            } else {
                return rs_logodds;
            }
        }

        bool
        isValidQualString(const char* qual) const;

        double getSemiAlignedReadMetric( const Alignment& alignment ) const;
		
		double getAlignmentScoreAfterBreakPoint(const char* qualityString,
                  const char* type) const;
				  
		double getBreakPointHypothesisScore(const Alignment& alignment, const unsigned breakPointPos, const bool
			enteringBreakPoint) const; 		  
		

    private:
        explicit
        ReadScorer(const bool isQphred);
        ~ReadScorer() {}

        double
        getAlignmentScore(const char* qualityString,
                          const char* type) const;

        enum { MAX_Q64 = 128 };
        const char _qmin;
        double _logpcorrectratio[MAX_Q64];
    };


    SequenceUtils() {}
    ~SequenceUtils() {}

    static
    void
    comp_error(const char c);
};

}
} // end namespace casava{ namespace { applications

#endif /*SEQUENCEUTILS_HH_*/