/**
 ** Copyright (c) 2007-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 readState.hh
 **
 ** \brief Class used to organise the read specific data for PickBest[Alignment|Pair].
 **
 **
 ** \author Stephen Allan
 **/
#ifndef READ_STATE_HH_
#define READ_STATE_HH_

#include <vector>
#include <string>
#include <iostream>
#include "common/ElandOutput.hh"

namespace gac = casava::common;

namespace casava
{
namespace alignment
{

    class ReadState
    {
        friend std::ostream & operator<<(std::ostream &, ReadState &);

        double bestScore_;
        double exactScore_;
        double restOfGenomeCorrection_;
        double scoreSingle_;
        int addShadowToSingletonThreshold_;
        int alignmentOk_;
        int alignmentPoor_;
        unsigned int numberResolved_;
        unsigned int numberUnique_;
        unsigned int positionOfMatch_;
        unsigned int readLength_;
        unsigned int singleReadAlignmentPosition_;
        unsigned int numberWithNoMatchPosition_;
        gac::ElandOutput elandOutput_;
        std::string bestInsert_;
        std::string chromosomeName_;
        std::string elandDetails_;
        std::string matchStrand_;
        std::string matchType_;
        std::string matchNeighbourhood_;
        std::string qualityValue_;
        std::string read_;
        std::string readId_;
        std::string singleReadAlignmentMatchChromosome_;
        std::string singleReadAlignmentStrand_;
        std::string typeSingle_;
        std::vector<std::string> qseqFileNames_;

        std::string elandExtendedFile_;
        std::string elandExtendedFilePath_;
        std::string shortAlignmentFormatFile_;
        std::string shortAlignmentFormatFilePath_;

    public:
        ReadState();
        ~ReadState(){}

        const std::string getChromosomeName(){ return chromosomeName_; };

        void setChromosomeName(const std::string &chromosomeName)
        { chromosomeName_ = chromosomeName; }

        const std::string &getSingleReadAlignmentMatchChromosome(){ return singleReadAlignmentMatchChromosome_; }

        void setSingleReadAlignmentMatchChromosome(const std::string &singleReadAlignmentMatchChromosome)
        { singleReadAlignmentMatchChromosome_ = singleReadAlignmentMatchChromosome; }

        std::string &getElandDetails()
        { return elandDetails_; }

        void setElandDetails(const std::string elandDetails)
        { elandDetails_ = elandDetails; }

        int getAddShadowToSingletonThreshold()
        { return addShadowToSingletonThreshold_; }

        void setAddShadowToSingletonThreshold(const int shadow)
        { addShadowToSingletonThreshold_ = shadow; }

        void incrementAddShadowToSingletonThreshold()
        { ++addShadowToSingletonThreshold_; }

        int getAlignmentOK()
        { return alignmentOk_; }

        void setAlignmentOK(const int alignmentCount)
        { alignmentOk_ = alignmentCount; }

        void incrementAlignmentOK()
        { ++alignmentOk_; }

        int getAlignmentPoor()
        { return alignmentPoor_; }

        void setAlignmentPoor(const int alignmentCount)
        { alignmentPoor_ = alignmentCount; }

        void incrementAlignmentPoor()
        { ++alignmentPoor_; }

        double getExactScore()
        { return exactScore_; }

        void setExactScore(const double exactScore)
        { exactScore_ = exactScore; }

        std::string getMatchNeighbourhood()
        { return matchNeighbourhood_; }

        void setMatchNeighbourhood(const std::string matchNeighbourhood)
        { matchNeighbourhood_ = matchNeighbourhood; }


        /*const*/ unsigned int getPositionOfMatch() const
        { return positionOfMatch_; }

        void setPositionOfMatch(const unsigned int positionOfMatch)
        { positionOfMatch_ = positionOfMatch; }


        unsigned int getSingleReadAlignmentPosition()
        { return singleReadAlignmentPosition_; }

        void setSingleReadAlignmentPosition(const unsigned int singleReadAlignmentPosition)
        { singleReadAlignmentPosition_ = singleReadAlignmentPosition; }

        unsigned int getNumberWithNoMatchPosition()
        { return numberWithNoMatchPosition_; }

        void setNumberWithNoMatchPosition(unsigned int numberWithNoMatchPosition)
        { numberWithNoMatchPosition_ = numberWithNoMatchPosition; }

        unsigned int incrementNumberWithNoMatchPosition()
        { return ++numberWithNoMatchPosition_; }

        std::string &getRead()
        { return read_; }

        void setRead(const std::string &read)
        { read_ = read; }


        std::string &getReadId()
        { return readId_; }

        void setReadId(const std::string &readId)
        { readId_ = readId; }


        unsigned int getReadLength()
        { return readLength_; }

        void setReadLength(const unsigned int readLength)
        { readLength_ = readLength; }


        double getRestOfGenomeCorrection()
        { return restOfGenomeCorrection_; }

        void setRestOfGenomeCorrection(const double restOfGenomeCorrection)
        { restOfGenomeCorrection_ = restOfGenomeCorrection; }


        const std::string &getMatchStrand() const
        { return matchStrand_; }

        void setMatchStrand(const std::string &matchStrand)
        { matchStrand_ = matchStrand; }


        std::string &getSingleReadAlignmentStrand()
        { return singleReadAlignmentStrand_; }

        void setSingleReadAlignmentStrand(const std::string &singleReadAlignmentStrand)
        { singleReadAlignmentStrand_ = singleReadAlignmentStrand; }


        std::string &getMatchType()
        { return matchType_; }

        void setMatchType(const std::string &matchType)
        { matchType_ = matchType; }

        double getBestScore()
        { return bestScore_; }

        void setBestScore(const double bestScore)
        { bestScore_ = bestScore; }


        unsigned int getNumberResolved()
        { return numberResolved_; }

        void setNumberResolved(const unsigned int numberResolved)
        { numberResolved_ = numberResolved; }

        void incrementNumberResolved()
        { ++numberResolved_; }


        unsigned int getNumberUnique()
        { return numberUnique_; }

        void setNumberUnique(const unsigned int numberUnique)
        { numberUnique_= numberUnique; }

        void incrementNumberUnique()
        { ++numberUnique_; }


        std::string getBestInsert()
        { return bestInsert_; }

        void setBestInsert(const std::string bestInsert)
        { bestInsert_ = bestInsert; }


        std::string &getQualityValue()
        { return qualityValue_; }

        void setQualityValue(const std::string &qualityValue)
        { qualityValue_ = qualityValue; }


        std::string &getTypeSingle()
        { return typeSingle_; }

        void setTypeSingle(const std::string &typeSingle)
        { typeSingle_ = typeSingle; }


        double getScoreSingle()
        { return scoreSingle_; }

        void setScoreSingle(const double scoreSingle)
        { scoreSingle_ = scoreSingle; }

        std::string &getElandExtendedFile()
        { return elandExtendedFile_; }

        void setElandExtendedFile(const std::string &elandExtendedFile)
        { elandExtendedFile_ = elandExtendedFile; }

        std::string &getElandExtendedFilePath()
        { return elandExtendedFilePath_; }

        void setElandExtendedFilePath(const std::string &elandExtendedFilePath)
        { elandExtendedFilePath_ = elandExtendedFilePath; }


        std::string &getShortAlignmentFormatFile()
        { return shortAlignmentFormatFile_; }

        void setShortAlignmentFormatFile(const std::string &shortAlignmentFormatFile)
        { shortAlignmentFormatFile_ = shortAlignmentFormatFile; }


        std::string &getShortAlignmentFormatFilePath()
        { return shortAlignmentFormatFilePath_; }

        void setShortAlignmentFormatFilePath(const std::string &shortAlignmentFormatFilePath)
        { shortAlignmentFormatFilePath_ = shortAlignmentFormatFilePath; }


        gac::ElandOutput &getElandOutput()
        { return elandOutput_; }

        void setElandOutput(const gac::ElandOutput &elandOutput)
        { elandOutput_ = elandOutput; }

        std::vector<std::string> &getQseqFileNames()
        { return qseqFileNames_; }

        void setQseqFileNames(const std::vector<std::string> &qseqFileNames)
        { qseqFileNames_ = qseqFileNames; }

        void qseqFileNameInsert(const std::string &fileName)
        { qseqFileNames_.push_back(fileName); }
   };



} // alignment
} // casava


#endif // READ_STATE_HH_