/*****************************************************************************
#   Copyright (C) 1994-2008 by David Gordon.
#   All rights reserved.                           
#                                                                           
#   This software is part of a beta-test version of the Consed/Autofinish
#   package.  It should not be redistributed or
#   used for any commercial purpose, including commercially funded
#   sequencing, without written permission from the author and the
#   University of Washington.
#   
#   This software is provided ``AS IS'' and any express or implied
#   warranties, including, but not limited to, the implied warranties of
#   merchantability and fitness for a particular purpose, are disclaimed.
#   In no event shall the authors or the University of Washington be
#   liable for any direct, indirect, incidental, special, exemplary, or
#   consequential damages (including, but not limited to, procurement of
#   substitute goods or services; loss of use, data, or profits; or
#   business interruption) however caused and on any theory of liability,
#   whether in contract, strict liability, or tort (including negligence
#   or otherwise) arising in any way out of the use of this software, even
#   if advised of the possibility of such damage.
#
#   Building Consed from source is error prone and not simple which is
#   why I provide executables.  Due to time limitations I cannot
#   provide any assistance in building Consed.  Even if you do not
#   modify the source, you may introduce errors due to using a
#   different version of the compiler, a different version of motif,
#   different versions of other libraries than I used, etc.  For this
#   reason, if you discover Consed bugs, I can only offer help with
#   those bugs if you first reproduce those bugs with an executable
#   provided by me--not an executable you have built.
# 
#   Modifying Consed is also difficult.  Although Consed is modular,
#   some modules are used by many other modules.  Thus making a change
#   in one place can have unforeseen effects on many other features.
#   It may takes months for you to notice these other side-effects
#   which may not seen connected at all.  It is not feasable for me to
#   provide help with modifying Consed sources because of the
#   potentially huge amount of time involved.
#
#*****************************************************************************/
#ifndef subcloneTTemplate_included
#define subcloneTTemplate_included

#include    "rwcstring.h"
#include    "rwtptrorderedvector.h"
#include    "bool.h"
#include    "primerType.h"
#include    "locatedFragment.h"

class Contig;
class library;

// these are for aFlags
const int LEFT_CONS_POS_SET = 1;
const int RIGHT_CONS_POS_SET = 2;
const int LEFT_CONS_POS_EQUAL_OR_FURTHER_LEFT = 4;
const int LEFT_CONS_POS_EQUAL_OR_FURTHER_RIGHT = 8;
const int RIGHT_CONS_POS_EQUAL_OR_FURTHER_LEFT = 16;
const int RIGHT_CONS_POS_EQUAL_OR_FURTHER_RIGHT = 32;
const int RIGHT_CONS_POS_EXACT = 64;
const int LEFT_CONS_POS_EXACT = 128;



class subcloneTTemplate {
public:
   RWCString soTemplateName_;
   RWCString soLibrary_;
   library* pLibrary_;
   RWTPtrOrderedVector<LocatedFragment> aReads_;

   // this is the master problem flag--only necessary to check this flag
   bool bOKToUseThisTemplate_;
   // here are the reasons:
   bool bBadTemplateFile_;
   bool bBadLibraryFile_;
   bool bShortInsert_;
   bool bReadsAreInconsistent_;
   bool bReadPairTooFarApart_;
   bool bUnalignedHighQualityRegionTooLong_;
   bool bHasSeriousHighQualityDiscrepancies_;
   bool bIsChimeric_;
   bool bInconsistentGapSpanning_;

   // just used by AssemblyView
   bool bDoNotShowInAssemblyView_;

   // use pLibrary_->bSingleNotDoubleStranded_
   //   bool bTemplateIsDoubleStranded_;


   bool bOKToUseThisTemplateForCalculatingInsertSizeFromForwardReversePairs_;
   int nInsertSizeFromForwardReversePair_;

   bool bChosenPriorToMakingListOfExperimentCandidates_;

   // aContigs_ is the list of contigs for which there
   // is a universal primer read
   // In each such contig, aUnpaddedLeft_ and aUnpaddedRight_ give 
   // the starting and ending location of the template.
   // aFlags indicates whether these locations are known exactly
   // or approximately.  (See constants above for values.)
   RWTPtrOrderedVector<Contig> aContigs_;
   RWTValOrderedVector<int> aUnpaddedLeft_;
   RWTValOrderedVector<int> aUnpaddedRight_;
   RWTValOrderedVector<int> aFlags_;

   bool bHasForwardAndReversePair_;

   // used to search for a template for a primer
   // Note:  this structure
   Contig* pContig_;
   // Start means Left and End means Right
   int nUnpaddedStart_;
   int nUnpaddedEnd_;
   bool bUnpaddedStartKnownPrecisely_;
   bool bUnpaddedEndKnownPrecisely_;
   bool bOKToUseForTopStrandReads_;
   bool bOKToUseForBottomStrandReads_;
   
   bool bErrorRateCalculated_;
   double dErrorRate_;

public:
   subcloneTTemplate(LocatedFragment* pLocFrag );

   subcloneTTemplate() : bErrorRateCalculated_( false ), pLibrary_( NULL )
      {}  // just for duplicating a subclone template--see subcloneTTemplate.cpp
          // and all fields will be set by the default operator= method
   ~subcloneTTemplate() {}

   // copy constructor for newsub = new subcloneTTemplate( *this );
   subcloneTTemplate( const subcloneTTemplate& sub);
   
   void processingAfterAllReadsAdded();
   void processingAfterAddedAllTemplatesInThisLibrary();
   void transferLibraryNameFromReadsToSubcloneTTemplate();

   // required for RWTPtrOrderedVector
   
   bool operator==( const subcloneTTemplate& sub ) const {
      return( this == &sub );
   }

   // required for resort part of mbtPtrOrderedVector

   bool operator<( const subcloneTTemplate& sub ) const {
      return( nUnpaddedStart_ < 
              sub.nUnpaddedStart_ );
   }


   RWCString soGetName() { return soTemplateName_; }


   void setRightUnpaddedExact( const int nUnpadded, const int nIndex );
   void setLeftUnpaddedExact( const int nUnpadded, const int nIndex );

   void tryToAddTemplateToPrimer( primerType* pPrimer );
   void calculateErrorRateIfNecessary();
   void figureOutWhichStrandsTheTemplateHas( Contig* pContig );

   bool bReadsAreConsistent();
   void determineIfOKToUseTemplate();

   void inventoryUniversalPrimerReadsForGapFlanking(
            bool& bUniversalForwardExists,
            bool& bUniversalForwardExistsInThisContig,
            bool& bUniversalForwardIsInBottomStrandOfThisContig,
            bool& bUniversalReverseExists,
            bool& bUniversalReverseExistsInThisContig,
            bool& bUniversalReverseIsInBottomStrandOfThisContig,
            Contig* pContig );

   void walkingReadByItselfInContig( LocatedFragment* pLocFrag);

   void dumpTemplate();
   bool bCalculateInsertSizeFromForwardReversePair();

   bool bHasAnotherReadInADifferentContig( 
                              LocatedFragment* pOriginalRead,
                              LocatedFragment*& pAnotherRead );

   bool bHasAnotherReadInADifferentContig2(
             LocatedFragment* pOriginalRead,
             RWTPtrOrderedVector<LocatedFragment>* pArrayOfLocatedFragments );

   bool bHasAnotherUnivPrimerReadInADifferentContig(
                              LocatedFragment* pOriginalRead,
                              LocatedFragment*& pAnotherRead );

   bool bTemplateHasForwardReversePair();

   bool bPreferSelfTemplate( primerType* pPrimer,
                             subcloneTTemplate* pOtherSub );

   
   bool bHasAlignedForwardReversePair( LocatedFragment*& pBestForwardRead,
                                       LocatedFragment*& pBestReverseRead );

   bool bHasForwardReversePairInSameContig(
                                LocatedFragment*& pBestForwardRead,
                                LocatedFragment*& pBestReverseRead );

   bool bHasForwardReversePairSortByContigName(
                                               LocatedFragment*& pLocFrag1,
                                               LocatedFragment*& pLocFrag2 );

   bool bHasAConsistentFwdRevPair( 
            LocatedFragment*& pFwdRead,
            LocatedFragment*& pRevRead,
            bool& bHasFwdRevPair,
            char& cProblem );

   bool bOKToCallDeNovoUniversalPrimerRead( 
                                           bool& bTopNotBottomStrand,
                                           int& nReadType,
                                           Contig* pContig );

   bool bIsForwardNotReverseStrand( const bool bTopNotBottomStrandOfContig,
                                    Contig* pContig );

   bool bIsForwardReversePairConsistent( LocatedFragment* pFwdLocFrag,
                                         LocatedFragment* pRevLocFrag,
                                         char& cProblem );

   bool bThereIsAlreadySuchAnAutofinishUniversalPrimerRead( 
                                          const bool bForwardNotReverse,
                                          LocatedFragment*& pExistingLocFrag );

   void flagSubcloneIfBadTemplateOrBadLibrary();

   void markTemplateBadIfInsertSeemsTooBig();

   bool bIsSameContigFwdRevPairTooFarApart( 
                                         LocatedFragment* pLocFrag1,
                                         LocatedFragment* pLocFrag2 );

   bool bIsGapSpanningFwdRevPairTooFarApart( 
                                   LocatedFragment* pLocFrag1,
                                   LocatedFragment* pLocFrag2,
                                   bool& bDoNotKnow );
   
};

#endif