/*****************************************************************************
#   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.
#
#*****************************************************************************/
#include    "userDefinedTagFieldType.h"
#include    "rwcstring.h"
#include    "tag.h"
#include    "bIsNumericLongMaybeWithWhitespace.h"
#include    "bIsNumericDouble.h"
#include    "consed.h"
#include    "userDefinedTagField.h"



// used, when the user enters data, to check that the data is valid

bool userDefinedTagFieldType :: bIsOK( const RWCString& soEnteredData,
                                    tag* pTag,
                                    RWCString& soErrorMessage ) {

   soErrorMessage = "";
   userDefinedTagField* pUserDefinedTagField = NULL;

   if ( !pTag->pArrayOfUserDefinedTagFields_ ) {
      pTag->pArrayOfUserDefinedTagFields_ = 
         new RWTPtrOrderedVector<userDefinedTagField>;
   }
   
   if ( eFieldType_ == eString ) {
      
      pUserDefinedTagField = 
         new userDefinedStringTagField();
      
      ((userDefinedStringTagField*)pUserDefinedTagField)->so_ = soEnteredData;

   }
   else if ( eFieldType_ == eInteger ) {

      long l;
      if ( !bIsNumericLongMaybeWithWhitespace( soEnteredData, l ) ) {
         soErrorMessage = "entered field ";
         soErrorMessage += soFieldName_;
         soErrorMessage += " is not an integer";
         return false;
      }

      pUserDefinedTagField = new userDefinedIntegerTagField();
      ((userDefinedIntegerTagField*)pUserDefinedTagField)->l_ = l;
   }
   else if ( eFieldType_ == eFloating ) {
      
      double d;
      if ( !bIsNumericDouble( soEnteredData, d ) ) {
         soErrorMessage = "entered field ";
         soErrorMessage += soFieldName_;
         soErrorMessage += " is not a floating point number";
         return false;
      }

      pUserDefinedTagField = new userDefinedFloatingTagField();

      ((userDefinedFloatingTagField*)pUserDefinedTagField)->d_ = d;
   }
   else if ( eFieldType_ == ePointer ) {
      
      // first convert this to an integer

      long lTagID;
      if ( !bIsNumericLongMaybeWithWhitespace( soEnteredData, lTagID ) ) {
         soErrorMessage = "entered field ";
         soErrorMessage += soFieldName_;
         soErrorMessage += " is not an integer";
         return false;
      }

      // now see if I can find a tag with this ID:

      tag* pFoundTag = ConsEd::pGetAssembly()->pFindTagWithThisID( lTagID );
      if ( !pFoundTag ) {
         soErrorMessage = "entered field ";
         soErrorMessage += soFieldName_;
         soErrorMessage += ": there is no with ID ";
         soErrorMessage += RWCString( (long) lTagID );

         return false;
      }

      if ( pFoundTag->soType_ != soPointerToWhichTagType_ ) {
         soErrorMessage = "entered field ";
         soErrorMessage += soFieldName_;
         soErrorMessage += ": the tag with this ID is of type ";
         soErrorMessage += pFoundTag->soType_;
         soErrorMessage += " at location ";
         soErrorMessage += pFoundTag->pGetContig()->soGetName();
         soErrorMessage += " from ";
         soErrorMessage += RWCString( (long) pFoundTag->nGetUnpaddedStart() );
         soErrorMessage += " to ";
         soErrorMessage += RWCString( (long) pFoundTag->nGetUnpaddedEnd() );
         soErrorMessage += " but this field requires a pointer to a tag of type ";
         soErrorMessage += soPointerToWhichTagType_;
         return false;
      }

      pUserDefinedTagField = new userDefinedPointerTagField();

      ((userDefinedPointerTagField*)pUserDefinedTagField)->lID_ = lTagID;
      ((userDefinedPointerTagField*)pUserDefinedTagField)->pTag_ = pFoundTag;
   }
   else
      assert( false );


   // this will be true for all types
   pUserDefinedTagField->pUserDefinedTagFieldType_ = this;

   pTag->pArrayOfUserDefinedTagFields_->insert( 
                                        pUserDefinedTagField );
   return true;
}



bool userDefinedTagFieldType :: bFoundCorrectNumberOfCopies( 
               RWCString& soErrorMessage ) {

   if ( eRepeatCode_ == eOnce ) {
      if ( nNumberOfCopiesFound_ == 1 ) 
         return true;
      else {
         soErrorMessage = soFieldName_ + 
            " must have exactly one copy but found " +
            RWCString( (long) nNumberOfCopiesFound_ ) +
            " copies so far";
         return false;
      }
   }
   else if ( eRepeatCode_ == eZeroOrOne ) {
      if ( nNumberOfCopiesFound_ == 0 || nNumberOfCopiesFound_ == 1 ) 
         return true;
      else {
         soErrorMessage = soFieldName_ +
            " must have 0 or one copy but found " +
            RWCString( (long) nNumberOfCopiesFound_ ) +
            " copies so far";
         return false;
      }
   }
   else if ( eRepeatCode_ == eZeroOrMore ) {
      return true;
   }
   else if ( eRepeatCode_ == eOneOrMore ) {
      if ( nNumberOfCopiesFound_ > 0 )
         return true;
      else {
         soErrorMessage = soFieldName_ +
            " must have 1 or more copies but found none";
         return false;
      }
   }

}