// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

**********************************************************************

*   Copyright (C) 2001-2008,2010 IBM and others. All rights reserved.

**********************************************************************

*   Date        Name        Description

*  03/22/2000   helena      Creation.

**********************************************************************

*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION

#include "unicode/brkiter.h"

#include "unicode/schriter.h"

#include "unicode/search.h"

#include "usrchimp.h"

#include "cmemory.h"

// public constructors and destructors -----------------------------------

U_NAMESPACE_BEGIN

SearchIterator::SearchIterator(const SearchIterator &other)

    : UObject(other)

{   

    m_breakiterator_            = other.m_breakiterator_;

    m_text_                     = other.m_text_;

    m_search_                   = (USearch *)uprv_malloc(sizeof(USearch));   

    m_search_->breakIter        = other.m_search_->breakIter;

    m_search_->isCanonicalMatch = other.m_search_->isCanonicalMatch;

    m_search_->isOverlap        = other.m_search_->isOverlap;

    m_search_->elementComparisonType = other.m_search_->elementComparisonType;

    m_search_->matchedIndex     = other.m_search_->matchedIndex;

    m_search_->matchedLength    = other.m_search_->matchedLength;

    m_search_->text             = other.m_search_->text;

    m_search_->textLength       = other.m_search_->textLength;

}

SearchIterator::~SearchIterator()

{

    if (m_search_ != NULL) {

        uprv_free(m_search_);

    }

}

// public get and set methods ----------------------------------------

void SearchIterator::setAttribute(USearchAttribute       attribute,

                                  USearchAttributeValue  value,

                                  UErrorCode            &status)

{

    if (U_SUCCESS(status)) {

        switch (attribute)

        {

        case USEARCH_OVERLAP :

            m_search_->isOverlap = (value == USEARCH_ON ? TRUE : FALSE);

            break;

        case USEARCH_CANONICAL_MATCH :

            m_search_->isCanonicalMatch = (value == USEARCH_ON ? TRUE : FALSE);

            break;

        case USEARCH_ELEMENT_COMPARISON :

            if (value == USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD || value == USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD) {

                m_search_->elementComparisonType = (int16_t)value;

            } else {

                m_search_->elementComparisonType = 0;

            }

            break;

        default:

            status = U_ILLEGAL_ARGUMENT_ERROR;

        }

    }

    if (value == USEARCH_ATTRIBUTE_VALUE_COUNT) {

        status = U_ILLEGAL_ARGUMENT_ERROR;

    }

}

USearchAttributeValue SearchIterator::getAttribute(

                                          USearchAttribute  attribute) const

{

    switch (attribute) {

    case USEARCH_OVERLAP :

        return (m_search_->isOverlap == TRUE ? USEARCH_ON : USEARCH_OFF);

    case USEARCH_CANONICAL_MATCH :

        return (m_search_->isCanonicalMatch == TRUE ? USEARCH_ON : 

                                                                USEARCH_OFF);

    case USEARCH_ELEMENT_COMPARISON :

        {

            int16_t value = m_search_->elementComparisonType;

            if (value == USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD || value == USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD) {

                return (USearchAttributeValue)value;

            } else {

                return USEARCH_STANDARD_ELEMENT_COMPARISON;

            }

        }

    default :

        return USEARCH_DEFAULT;

    }

}

int32_t SearchIterator::getMatchedStart() const

{

    return m_search_->matchedIndex;

}

int32_t SearchIterator::getMatchedLength() const

{

    return m_search_->matchedLength;

}

void SearchIterator::getMatchedText(UnicodeString &result) const

{

    int32_t matchedindex  = m_search_->matchedIndex;

    int32_t     matchedlength = m_search_->matchedLength;

    if (matchedindex != USEARCH_DONE && matchedlength != 0) {

        result.setTo(m_search_->text + matchedindex, matchedlength); 

    }

    else {

        result.remove();

    }

}

void SearchIterator::setBreakIterator(BreakIterator *breakiter, 

                                      UErrorCode &status)

{

    if (U_SUCCESS(status)) {

#if 0

        m_search_->breakIter = NULL;

        // the c++ breakiterator may not make use of ubreakiterator.

        // so we'll have to keep track of it ourselves.

#else

        // Well, gee... the Constructors that take a BreakIterator

        // all cast the BreakIterator to a UBreakIterator and

        // pass it to the corresponding usearch_openFromXXX

        // routine, so there's no reason not to do this.

        //

        // Besides, a UBreakIterator is a BreakIterator, so

        // any subclass of BreakIterator should work fine here...

        m_search_->breakIter = (UBreakIterator *) breakiter;

#endif

        m_breakiterator_ = breakiter;

    }

}

const BreakIterator * SearchIterator::getBreakIterator(void) const

{

    return m_breakiterator_;

}

void SearchIterator::setText(const UnicodeString &text, UErrorCode &status)

{

    if (U_SUCCESS(status)) {

        if (text.length() == 0) {

            status = U_ILLEGAL_ARGUMENT_ERROR;

        }

        else {

            m_text_        = text;

            m_search_->text = m_text_.getBuffer();

            m_search_->textLength = m_text_.length();

        }

    }

}

void SearchIterator::setText(CharacterIterator &text, UErrorCode &status)

{

    if (U_SUCCESS(status)) {

        text.getText(m_text_);

        setText(m_text_, status);

    }

}

const UnicodeString & SearchIterator::getText(void) const

{

    return m_text_;

}

// operator overloading ----------------------------------------------

UBool SearchIterator::operator==(const SearchIterator &that) const

{

    if (this == &that) {

        return TRUE;

    }

    return (m_breakiterator_            == that.m_breakiterator_ &&

            m_search_->isCanonicalMatch == that.m_search_->isCanonicalMatch &&

            m_search_->isOverlap        == that.m_search_->isOverlap &&

            m_search_->elementComparisonType == that.m_search_->elementComparisonType &&

            m_search_->matchedIndex     == that.m_search_->matchedIndex &&

            m_search_->matchedLength    == that.m_search_->matchedLength &&

            m_search_->textLength       == that.m_search_->textLength &&

            getOffset() == that.getOffset() &&

            (uprv_memcmp(m_search_->text, that.m_search_->text, 

                              m_search_->textLength * sizeof(UChar)) == 0));

}

// public methods ----------------------------------------------------

int32_t SearchIterator::first(UErrorCode &status)

{

    if (U_FAILURE(status)) {

        return USEARCH_DONE;

    }

    setOffset(0, status);

    return handleNext(0, status);

}

int32_t SearchIterator::following(int32_t position, 

                                      UErrorCode &status)

{

    if (U_FAILURE(status)) {

        return USEARCH_DONE;

    }

    setOffset(position, status);

    return handleNext(position, status);

}

int32_t SearchIterator::last(UErrorCode &status)

{

    if (U_FAILURE(status)) {

        return USEARCH_DONE;

    }

    setOffset(m_search_->textLength, status);

    return handlePrev(m_search_->textLength, status);

}

int32_t SearchIterator::preceding(int32_t position, 

                                      UErrorCode &status)

{

    if (U_FAILURE(status)) {

        return USEARCH_DONE;

    }

    setOffset(position, status);

    return handlePrev(position, status);

}

int32_t SearchIterator::next(UErrorCode &status)

{

    if (U_SUCCESS(status)) {

        int32_t offset = getOffset();

        int32_t matchindex  = m_search_->matchedIndex;

        int32_t     matchlength = m_search_->matchedLength;

        m_search_->reset = FALSE;

        if (m_search_->isForwardSearching == TRUE) {

            int32_t textlength = m_search_->textLength;

            if (offset == textlength || matchindex == textlength || 

                (matchindex != USEARCH_DONE && 

                matchindex + matchlength >= textlength)) {

                // not enough characters to match

                setMatchNotFound();

                return USEARCH_DONE; 

            }

        }

        else {

            // switching direction. 

            // if matchedIndex == USEARCH_DONE, it means that either a 

            // setOffset has been called or that previous ran off the text

            // string. the iterator would have been set to offset 0 if a 

            // match is not found.

            m_search_->isForwardSearching = TRUE;

            if (m_search_->matchedIndex != USEARCH_DONE) {

                // there's no need to set the collation element iterator

                // the next call to next will set the offset.

                return matchindex;

            }

        }

        if (matchlength > 0) {

            // if matchlength is 0 we are at the start of the iteration

            if (m_search_->isOverlap) {

                offset ++;

            }

            else {

                offset += matchlength;

            }

        }

        return handleNext(offset, status);

    }

    return USEARCH_DONE;

}

int32_t SearchIterator::previous(UErrorCode &status)

{

    if (U_SUCCESS(status)) {

        int32_t offset;

        if (m_search_->reset) {

            offset                       = m_search_->textLength;

            m_search_->isForwardSearching = FALSE;

            m_search_->reset              = FALSE;

            setOffset(offset, status);

        }

        else {

            offset = getOffset();

        }

        int32_t matchindex = m_search_->matchedIndex;

        if (m_search_->isForwardSearching == TRUE) {

            // switching direction. 

            // if matchedIndex == USEARCH_DONE, it means that either a 

            // setOffset has been called or that next ran off the text

            // string. the iterator would have been set to offset textLength if 

            // a match is not found.

            m_search_->isForwardSearching = FALSE;

            if (matchindex != USEARCH_DONE) {

                return matchindex;

            }

        }

        else {

            if (offset == 0 || matchindex == 0) {

                // not enough characters to match

                setMatchNotFound();

                return USEARCH_DONE; 

            }

        }

        if (matchindex != USEARCH_DONE) {

            if (m_search_->isOverlap) {

                matchindex += m_search_->matchedLength - 2;

            }

            return handlePrev(matchindex, status); 

        }

        return handlePrev(offset, status);

    }

    return USEARCH_DONE;

}

void SearchIterator::reset()

{

    UErrorCode status = U_ZERO_ERROR;

    setMatchNotFound();

    setOffset(0, status);

    m_search_->isOverlap          = FALSE;

    m_search_->isCanonicalMatch   = FALSE;

    m_search_->elementComparisonType = 0;

    m_search_->isForwardSearching = TRUE;

    m_search_->reset              = TRUE;

}

// protected constructors and destructors -----------------------------

SearchIterator::SearchIterator()

{

    m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));

    m_search_->breakIter          = NULL;

    m_search_->isOverlap          = FALSE;

    m_search_->isCanonicalMatch   = FALSE;

    m_search_->elementComparisonType = 0;

    m_search_->isForwardSearching = TRUE;

    m_search_->reset              = TRUE;

    m_search_->matchedIndex       = USEARCH_DONE;

    m_search_->matchedLength      = 0;

    m_search_->text               = NULL;

    m_search_->textLength         = 0;

    m_breakiterator_              = NULL;

}

SearchIterator::SearchIterator(const UnicodeString &text, 

                                     BreakIterator *breakiter) :

                                     m_breakiterator_(breakiter),

                                     m_text_(text)

{

    m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));

    m_search_->breakIter          = NULL;

    m_search_->isOverlap          = FALSE;

    m_search_->isCanonicalMatch   = FALSE;

    m_search_->elementComparisonType = 0;

    m_search_->isForwardSearching = TRUE;

    m_search_->reset              = TRUE;

    m_search_->matchedIndex       = USEARCH_DONE;

    m_search_->matchedLength      = 0;

    m_search_->text               = m_text_.getBuffer();

    m_search_->textLength         = text.length();

}

SearchIterator::SearchIterator(CharacterIterator &text, 

                               BreakIterator     *breakiter) :

                               m_breakiterator_(breakiter)

{

    m_search_                     = (USearch *)uprv_malloc(sizeof(USearch));

    m_search_->breakIter          = NULL;

    m_search_->isOverlap          = FALSE;

    m_search_->isCanonicalMatch   = FALSE;

    m_search_->elementComparisonType = 0;

    m_search_->isForwardSearching = TRUE;

    m_search_->reset              = TRUE;

    m_search_->matchedIndex       = USEARCH_DONE;

    m_search_->matchedLength      = 0;

    text.getText(m_text_);

    m_search_->text               = m_text_.getBuffer();

    m_search_->textLength         = m_text_.length();

    m_breakiterator_             = breakiter;

}

// protected methods ------------------------------------------------------

SearchIterator & SearchIterator::operator=(const SearchIterator &that)

{

    if (this != &that) {

        m_breakiterator_            = that.m_breakiterator_;

        m_text_                     = that.m_text_;

        m_search_->breakIter        = that.m_search_->breakIter;

        m_search_->isCanonicalMatch = that.m_search_->isCanonicalMatch;

        m_search_->isOverlap        = that.m_search_->isOverlap;

        m_search_->elementComparisonType = that.m_search_->elementComparisonType;

        m_search_->matchedIndex     = that.m_search_->matchedIndex;

        m_search_->matchedLength    = that.m_search_->matchedLength;

        m_search_->text             = that.m_search_->text;

        m_search_->textLength       = that.m_search_->textLength;

    }

    return *this;

}

void SearchIterator::setMatchLength(int32_t length)

{

    m_search_->matchedLength = length;

}

void SearchIterator::setMatchStart(int32_t position)

{

    m_search_->matchedIndex = position;

}

void SearchIterator::setMatchNotFound() 

{

    setMatchStart(USEARCH_DONE);

    setMatchLength(0);

    UErrorCode status = U_ZERO_ERROR;

    // by default no errors should be returned here since offsets are within 

    // range.

    if (m_search_->isForwardSearching) {

        setOffset(m_search_->textLength, status);

    }

    else {

        setOffset(0, status);

    }

}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_COLLATION */