/* only call on an exon position */
  private char getPeptide(int bp, SeqFeatureI sf) {
    char base = '\0';
    SequenceI peptides = null;
    FeatureSetI parent = sf.getParent();

    int pepPos = -1;
    if (parent != null && parent.hasPeptideSequence()) {
      peptides = parent.getPeptideSequence();
      if (parent instanceof FeatureSet) {
        FeatureSet fs = (FeatureSet) parent;
        pepPos = fs.getPeptidePosForGenomicPos(bp);
      }

      if (pepPos >= 0 && pepPos < peptides.getLength()) {
        base = peptides.getBaseAt(pepPos);
      }
    }

    return base;
  }
  /**
   * @param position
   * @param tier
   * @return
   */
  public static int getOffset(int position, TierI tier) {

    SeqFeatureI sf = null;

    int offset = 0;
    if (tier.featureExsitsAt(position, Level.BOTTOM)) {
      sf = tier.featureAt(position, Level.BOTTOM);
      ReadingFrame exonFrame = ReadingFrame.valueOf(sf.getFrame());
      ReadingFrame tierFrame = tier.getReadingFrame();

      if (exonFrame == ReadingFrame.NONE
          && sf.getParent() != null
          && sf.getParent().isTranscript()) {
        FeatureSetI parent = sf.getParent();
        Transcript parentClone = (Transcript) sf.getParent().clone();

        int start = parentClone.getEnd();

        // the transcript start might be different than the lowest exon start
        // when in the middle of an edit
        if (parentClone.canHaveChildren()) {
          for (int i = 0; i < parentClone.size(); i++) {
            SeqFeatureI f = parentClone.getFeatureAt(i);
            if ((Strand.valueOf(f.getStrand()) == Strand.FORWARD && f.getStart() < start)
                || (Strand.valueOf(f.getStrand()) == Strand.REVERSE && f.getStart() > start))
              start = f.getStart();
          }
        }

        int translationStart = parentClone.getTranslationStart();
        int translationPos = parentClone.getFeaturePosition(translationStart);
        int oldstart = start;
        start += ((translationPos - 1) % 3) * parentClone.getStrand();

        parentClone.setTranslationStart(start);
        parentClone.setTranslationEnd(parentClone.getEnd());
        parentClone.setPeptideSequence(null);
        String translation = parentClone.translate();
        SequenceI sequence = parentClone.getPeptideSequence();

        int index = parent.getFeatureIndex(sf);
        exonFrame = ReadingFrame.valueOf(parentClone.getFeatureAt(index).getFrame());
      }

      if (tierFrame != exonFrame && sf.getParent() != null && sf.getParent().isTranscript()) {
        if (tierFrame == ReadingFrame.THREE) {
          offset = exonFrame == ReadingFrame.ONE ? -2 : -1;
        } else if (tierFrame == ReadingFrame.TWO) {
          offset = exonFrame == ReadingFrame.ONE ? -1 : 1;
        } else if (tierFrame == ReadingFrame.ONE) {
          offset = exonFrame == ReadingFrame.TWO ? 1 : 2;
        }
      }

      if (exonFrame == ReadingFrame.NONE) {
        offset = 0;
      }
    }

    return offset;
  }
  /**
   * Get component to be rendered, if pos outside of current range getFeatureAtPosition and reset
   * currentRange, if feature is non null and not an instance of FeatureSetI then its an exon, and
   * set isExon flag
   */
  public Component getBaseComponent(int position, TierI tier, Orientation o) {

    transcript = null;

    int bp = tier.getBasePair(position);
    int oldPos = position;

    // We need to change the position if dealing with aa view
    if (tier.getType() == SequenceType.AA) {
      int offset = getOffset(position, tier);
      bp += offset * tier.getStrand().toInt();
      position = tier.getPosition(bp);
    }

    char base = tier.charAt(position);

    if (tier.featureExsitsAt(position, TierI.Level.BOTTOM)) {
      this.state = State.EXON;
      SeqFeatureI feature = tier.featureAt(position, TierI.Level.BOTTOM);
      Transcript parentClone = null;
      Transcript otherParentClone = null;

      if (tier.getType() == SequenceType.AA
          && feature.getParent() != null
          && feature.getParent().isTranscript()) {

        FeatureSetI parent = feature.getParent();
        int index = parent.getFeatureIndex(feature);

        int start = parent.getEnd();
        // the transcript start might be different than the lowest exon start
        // when in the middle of an edit
        if (parent.canHaveChildren()) {
          for (int i = 0; i < parent.size(); i++) {
            SeqFeatureI sf = parent.getFeatureAt(i);
            if ((Strand.valueOf(sf.getStrand()) == Strand.FORWARD && sf.getStart() < start)
                || (Strand.valueOf(sf.getStrand()) == Strand.REVERSE && sf.getStart() > start))
              start = sf.getStart();
          }
        }

        int translationStart = parent.getTranslationStart();
        int translationEnd = parent.getTranslationEnd();
        int translationPos = parent.getFeaturePosition(translationStart);
        int oldstart = start;
        start += ((translationPos - 1) % 3) * parent.getStrand();

        // Tring to avoid all the recalculation...
        if (feature.getParent() == currentParent
            && start == currentStart
            && featureStart == feature.getStart()
            && featureEnd == feature.getEnd()) {
          parentClone = currentParentClone;
          otherParentClone = currentParentClone2;
        } else {
          // need to get a full translation so that we can get the amino acids
          // in the UTR region
          parentClone = (Transcript) feature.getParent().clone();
          otherParentClone = (Transcript) feature.getParent().clone();

          if (!parentClone.setTranslationStart(start)) {
            start = oldstart;
            TranslationI cds = otherParentClone.getTranslation();
            cds.calcTranslationStartForLongestPeptide();
            translationStart = otherParentClone.getTranslationStart();
            translationPos = otherParentClone.getFeaturePosition(translationStart);
            start += ((translationPos - 1) % 3) * otherParentClone.getStrand();
            parentClone.setTranslationStart(start);
          }

          parentClone.setTranslationEnd(parentClone.getEnd());
          parentClone.setPeptideSequence(null);

          String translation = parentClone.translate();
          SequenceI sequence = parentClone.getPeptideSequence();

          currentParent = (Transcript) feature.getParent();
          currentParentClone = parentClone;
          currentParentClone2 = otherParentClone;
          currentStart = start;
          featureStart = feature.getStart();
          featureEnd = feature.getEnd();

          if (otherParentClone.getFeatureContaining(translationEnd) == null) {
            TranslationI cds = otherParentClone.getTranslation();
            cds.setTranslationEndFromStart();
          }
        }

        SeqFeatureI sf = parentClone.getFeatureAt(index);

        if (bp >= sf.getLow() && bp <= sf.getHigh()) {
          base = getPeptide(bp, sf);
        } else {
          base = '\0';
        }

        if (otherParentClone != null) {
          feature = otherParentClone.getFeatureAt(index);
        }

      } else if (tier.getType() == SequenceType.AA
          && feature.getParent() != null
          && !feature.getParent().isTranscript()) {
        base = '\0';
      }

      if (isUTR(bp, feature, tier)) {
        this.state = State.UTR;
      }

      if (isTranslationStart(bp, feature)) {
        this.state = State.TRANSLATION_START;
      }

      if (isTranslationEnd(bp, feature)) {
        this.state = State.TRANSLATION_END;
      }

      // Can have an error or a shift on a position but not both
      if (isSequencingErrorPosition(bp, feature, tier.getType())) {
        this.state = State.ERROR;
        // set base to the base of the new sequence?
      }

      if (isShiftPosition(bp, feature, tier.getType())) {
        this.state = State.SHIFT;
      }

    } else if (tier.featureExsitsAt(position, TierI.Level.TOP)) {
      SeqFeatureI feature = tier.featureAt(position, Level.TOP);
      this.state = State.INTRON;
      if (tier.getType() == SequenceType.AA) {
        base = '\0';
      }

      int start = feature.getEnd();
      int end = feature.getStart();

      if (feature.canHaveChildren()) {
        for (int i = 0; i < feature.size(); i++) {
          SeqFeatureI sf = feature.getFeatureAt(i);
          if ((Strand.valueOf(sf.getStrand()) == Strand.FORWARD && sf.getStart() < start)
              || (Strand.valueOf(sf.getStrand()) == Strand.REVERSE && sf.getStart() > start))
            start = sf.getStart();

          if ((Strand.valueOf(sf.getStrand()) == Strand.FORWARD && sf.getEnd() > end)
              || (Strand.valueOf(sf.getStrand()) == Strand.REVERSE && sf.getEnd() < end))
            end = sf.getEnd();
        }
      }

      if (bp <= Math.min(start, end) || bp >= Math.max(start, end)) {
        this.state = State.OUT;
        base = '\0';
      }
    } else {
      this.state = State.OUT;
      base = '\0';
    }

    if (!(state == State.SHIFT || state == State.ERROR)
        && getRegionLow() <= position
        && position <= getRegionHigh()) {
      this.state = State.SELECTED;
      base = tier.charAt(oldPos);
    }

    init(base);
    return this;
  }