// Constructor::TextContext
  //
  // Generates a TextContext Object.
  //
  // Generates before and after contexts based on given length and values
  //
  // Parameters
  //
  // * primary -- TextPrimary object to be tested against context
  // * constraint -- TextConstraint object attached to this context
  // * checkSumType -- Hash for checksum
  // * contextLength - length (in chars) of the context used for testing
  //
  public TextContext(
      TextPrimary primary, TextConstraint constraint, HashType checkSumType, int contextLength) {
    super();
    this.checkSumType = checkSumType;
    //	Testing if content matches the bit-checksum tests

    this.checkSum = checkSum(primary.getContent(), checkSumType);

    int beforeStart = constraint.getStartPos() - contextLength;
    beforeStart = Math.max(0, beforeStart);
    int beforeEnd = constraint.getStartPos();

    int afterStart = constraint.getEndPos();
    int afterEnd = constraint.getEndPos() + contextLength;
    afterEnd = Math.min(primary.getContent().length(), afterEnd);

    // Evaluating how much of selected text to store
    this.totalSelectionLength = primary.getContent().length();
    int cLength = this.totalSelectionLength;
    if (this.totalSelectionLength > DEFAULT_CONTEXTLENGTH) {
      double half = (double) (this.totalSelectionLength / 2);
      cLength = (int) (Math.floor(half * percentStorage));
      this.beginSel = primary.getContent().substring(beforeEnd, (beforeEnd + cLength));
      this.endSel = primary.getContent().substring((afterStart - cLength), afterStart);
      this.totalSelection = this.beginSel.concat(this.endSel);
    } else {
      // Use the entire selection
      this.beginSel = "";
      this.endSel = "";
      this.totalSelection = primary.getContent();
    }

    this.beforeContext = primary.getContent().substring(beforeStart, beforeEnd);
    this.afterContext = primary.getContent().substring(afterStart, afterEnd);
  }
  @Override
  public Constraint match(Primary primary, TextConstraint originalConstraint)
      throws Context.NoMatchFoundException {
    if (!(primary instanceof TextPrimary)) throw new IllegalArgumentException();
    TextPrimary textPrimary = (TextPrimary) primary;

    // TextConstraint result = shingleCloudMatch(textPrimary.getContent());
    TextConstraint result = exactMatch(textPrimary.getContent(), originalConstraint);
    if (result == null) {
      // perform fuzzy matching
      result = gstMatch(textPrimary.getContent(), originalConstraint);
    }

    // sanity check
    if (result.getEndPos() < result.getStartPos()) throw new Context.NoMatchFoundException();

    return result;
  }
  // ## TextConstraint gstMatch
  //
  // Matches a constraint within passed content. Makes sure that
  // the constraint text is found within the content, but in order to
  // be a true match, it has to match in or near the same location as
  // the original constraint
  //
  // Parameters:
  //
  // * primaryContent - String - content to find context within
  //
  // * originalConstraint - TextConstraint - object to test internal constraint against
  private TextConstraint gstMatch(String primaryContent, TextConstraint originalConstraint)
      throws NoMatchFoundException {
    GST g = createGST(this.beforeContext.length(), primaryContent);

    g.match(this.beforeContext);
    if (g.getTiles().size() == 0) throw new Context.NoMatchFoundException();
    int startMatch = -1;
    int maxMatchIndex =
        originalConstraint.getStartPos()
            - (this.beforeContext.length() + (int) Math.ceil((this.beforeContext.length() / 3)));
    int minMatchIndex =
        originalConstraint.getStartPos()
            - (int) Math.ceil(Math.ceil(this.beforeContext.length() / 3));
    int i;
    // go through each matched TILE and see
    // if the match is close to our context
    for (GSTTile item : g.getTiles()) {
      i = item.getStart();
      if (i > startMatch && i > minMatchIndex && i <= maxMatchIndex) {
        startMatch = item.getStart();
      }
    }
    // Check if no matches found
    if (startMatch < 1) throw new Context.NoMatchFoundException();

    minMatchIndex =
        originalConstraint.getEndPos()
            + (this.afterContext.length() + (int) Math.ceil((this.beforeContext.length() / 3)));
    maxMatchIndex = originalConstraint.getEndPos() + this.afterContext.length();
    int endMatch = -1;

    for (GSTTile item : g.getTiles()) {
      i = item.getStart() + item.getLength();
      if (i > endMatch && i > minMatchIndex && i <= maxMatchIndex) {
        endMatch = item.getStart();
      }
    }

    if (endMatch < 1) throw new Context.NoMatchFoundException();

    return new TextConstraint(startMatch, endMatch);
  }
  private TextConstraint exactMatch(String primaryContent, TextConstraint originalConstraint)
      throws NoMatchFoundException {

    // find the text before the annotation
    // int startPos = primaryContent.indexOf(this.beforeContext);
    int startPos =
        findClosestIndexOf(
            this.beforeContext,
            originalConstraint.getStartPos() - this.beforeContext.length(),
            primaryContent);

    startPos += this.beforeContext.length();

    // find text after annotation
    // int endPos = primaryContent.indexOf(this.afterContext);
    int endPos =
        findClosestIndexOf(this.afterContext, originalConstraint.getEndPos(), this.totalSelection);

    if (endPos < 0 || startPos < 0) {
      // search through the selected content

      int positionTotal = 0;
      if (this.beginSel.length() > 0 && this.endSel.length() > 0) {
        int originalPosTotal =
            (originalConstraint.getStartPos()
                + (originalConstraint.getEndPos() - this.endSel.length()));

        // search beginning source selection, then end
        // selection, respectively
        int beginTotal =
            findClosestIndexOf(this.beginSel, originalConstraint.getStartPos(), primaryContent);

        int afterTotal =
            findClosestIndexOf(
                this.endSel,
                (originalConstraint.getEndPos() - this.endSel.length()),
                primaryContent);

        positionTotal = beginTotal + afterTotal;

        if (Math.abs(positionTotal - originalPosTotal) > 5) {
          return null;
        }

      } else {
        // search through total selection
        positionTotal =
            findClosestIndexOf(
                this.totalSelection, originalConstraint.getStartPos(), primaryContent);
        if (positionTotal < 0) return null;
      }
    }

    return new TextConstraint(startPos, endPos);
  }