/*
 * (C) Copyright IBM Corp. 1998-2004.  All Rights Reserved.
 *
 * The program is provided "as is" without any warranty express or
 * implied, including the warranty of non-infringement and the implied
 * warranties of merchantibility and fitness for a particular purpose.
 * IBM will not be liable for any damages suffered by you as a result
 * of using the Program. In no event will IBM be liable for any
 * special, indirect or consequential damages or lost profits even if
 * IBM has been advised of the possibility of their occurrence. IBM
 * will not be liable for any third party claims against you.
 */
// Requires Java2
package com.ibm.richtext.textformat;

import com.ibm.richtext.styledtext.MConstText;
import java.text.CharacterIterator;

import com.ibm.richtext.textlayout.attributes.AttributeMap;

///*JDK12IMPORTS
import java.text.AttributedCharacterIterator;
import java.util.Map;
import java.util.Set;
//JDK12IMPORTS*/

/*JDK11IMPORTS
import com.ibm.richtext.textlayout.attributes.AttributedCharacterIterator;
import com.ibm.richtext.textlayout.attributes.AttributedCharacterIterator.Attribute;
import com.ibm.richtext.textlayout.attributes.Map;
JDK11IMPORTS*/

/**
 * An AttributedCharacterIterator over an MConstText.
 */
public final class MTextIterator implements AttributedCharacterIterator,
                                            Cloneable {

    static final String COPYRIGHT =
                "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
    // memory leak, since this cache is never flushed

    private static class Matcher {
        
        boolean matches(Map lhs, Map rhs, Object query) {
            
            Object lhsVal = lhs.get(query);
            Object rhsVal = rhs.get(query);
            
            if (lhsVal == null) {
                return rhsVal == null;
            }
            else {
                return lhsVal.equals(rhsVal);
            }
        }
    }
    
    private static final Matcher ATTR_MATCHER = new Matcher();
    
    // Not quite optimal.  Could have a matcher that would decompose
    // a set once for repeated queries.  Of course that would require
    // allocation...
///*JDK12IMPORTS
    private static final Matcher SET_MATCHER = new Matcher() {
        
        boolean matches(Map lhs, Map rhs, Object query) {
            
            // Not using Iterator to simplify 1.1 port.
            Object[] elements = ((Set)query).toArray();
            for (int i=0; i < elements.length; i++) {
                if (!super.matches(lhs, rhs, elements[i])) {
                    return false;
                }
            }
            return true;
        }
    };
//JDK12IMPORTS*/
    
    private final class StyleCache {

        private int fRunStart = 0;
        private int fRunLimit = -1;
        private int fRangeStart;
        private int fRangeLimit;
        private AttributeMap fStyle;

        StyleCache(MConstText text, int start, int limit) {
            fText = text;
            fRangeStart = start;
            fRangeLimit = limit;
            update(start);
        }

        private void update(int pos) {
            if (pos < fRunStart || pos >= fRunLimit) {
                AttributeMap style = AttributeMap.EMPTY_ATTRIBUTE_MAP;
                if (pos < fRangeStart) {
                    fRunLimit = fRangeStart;
                    fRunStart = Integer.MIN_VALUE;
                }
                else if (pos > fRangeLimit) {
                    fRunStart = fRangeLimit;
                    fRunLimit = Integer.MAX_VALUE;
                }
                else {
                    fRunStart = Math.max(fRangeStart, fText.characterStyleStart(pos));
                    fRunStart = Math.max(fRunStart, fText.paragraphStart(pos));
                    
                    fRunLimit = Math.min(fRangeLimit, fText.characterStyleLimit(pos));
                    fRunLimit = Math.min(fRunLimit, fText.paragraphLimit(pos));
                    if (fRunStart < fRunLimit) {
                        style = fText.paragraphStyleAt(pos);
                        style = style.addAttributes(fText.characterStyleAt(pos));
                    }
                }
                fStyle = fFontResolver.applyFont(style);
            }
        }

        int getRunStart(int pos) {
            update(pos);
            return fRunStart;
        }

        int getRunLimit(int pos) {
            update(pos);
            return fRunLimit;
        }

        Map getStyle(int pos) {
            update(pos);
            return fStyle;
        }
    }

    private MConstText fText;
    private CharacterIterator fCharIter;
    private FontResolver fFontResolver;
    
    private StyleCache fStyleCache;

    /**
     * Create an MTextIterator over the range [start, limit).
     */
    public MTextIterator(MConstText text, 
                         FontResolver resolver,
                         int start, 
                         int limit) {

        fText = text;
        fFontResolver = resolver;
        fCharIter = text.createCharacterIterator(start, limit);

        fStyleCache = new StyleCache(text, start, limit);
    }

    /**
     * Sets the position to getBeginIndex() and returns the character at that
     * position.
     * @return the first character in the text, or DONE if the text is empty
     * @see #getBeginIndex
     */
    public char first() {
        return fCharIter.first();
    }

    /**
     * Sets the position to getEndIndex()-1 (getEndIndex() if the text is empty)
     * and returns the character at that position.
     * @return the last character in the text, or DONE if the text is empty
     * @see #getEndIndex
     */
    public char last() {
        return fCharIter.last();
    }

    /**
     * Gets the character at the current position (as returned by getIndex()).
     * @return the character at the current position or DONE if the current
     * position is off the end of the text.
     * @see #getIndex
     */
    public char current() {
        return fCharIter.current();
    }

    /**
     * Increments the iterator's index by one and returns the character
     * at the new index.  If the resulting index is greater or equal
     * to getEndIndex(), the current index is reset to getEndIndex() and
     * a value of DONE is returned.
     * @return the character at the new position or DONE if the new
     * position is off the end of the text range.
     */
    public char next() {
        return fCharIter.next();
    }

    /**
     * Decrements the iterator's index by one and returns the character
     * at the new index. If the current index is getBeginIndex(), the index
     * remains at getBeginIndex() and a value of DONE is returned.
     * @return the character at the new position or DONE if the current
     * position is equal to getBeginIndex().
     */
    public char previous() {
        return fCharIter.previous();
    }

    /**
     * Sets the position to the specified position in the text and returns that
     * character.
     * @param position the position within the text.  Valid values range from
     * getBeginIndex() to getEndIndex().  An IllegalArgumentException is thrown
     * if an invalid value is supplied.
     * @return the character at the specified position or DONE if the specified position is equal to getEndIndex()
     */
    public char setIndex(int position) {
        return fCharIter.setIndex(position);
    }

    /**
     * Returns the start index of the text.
     * @return the index at which the text begins.
     */
    public int getBeginIndex() {
        return fCharIter.getBeginIndex();
    }

    /**
     * Returns the end index of the text.  This index is the index of the first
     * character following the end of the text.
     * @return the index after the last character in the text
     */
    public int getEndIndex() {
        return fCharIter.getEndIndex();
    }

    /**
     * Returns the current index.
     * @return the current index.
     */
    public int getIndex() {
        return fCharIter.getIndex();
    }

    /**
     * Returns the index of the first character of the run
     * with respect to all attributes containing the current character.
     */
    public int getRunStart() {
        return fStyleCache.getRunStart(fCharIter.getIndex());
    }

    /**
     * Returns the index of the first character of the run
     * with respect to the given attribute containing the current character.
     */
    public int getRunStart(Object attribute) {

        return getRunStart(attribute, ATTR_MATCHER);
    }

    /**
     * Returns the index of the first character of the run
     * with respect to the given attribute containing the current character.
     */
///*JDK12IMPORTS
    public int getRunStart(Attribute attribute) {

        return getRunStart(attribute, ATTR_MATCHER);
    }
//JDK12IMPORTS*/

    /**
     * Returns the index of the first character of the run
     * with respect to the given attributes containing the current character.
     */
///*JDK12IMPORTS
    public int getRunStart(Set attributes) {

        return getRunStart(attributes, SET_MATCHER);
    }
//JDK12IMPORTS*/
    
    private int getRunStart(Object query, Matcher matcher) {

        int runStart = getRunStart();
        int rangeStart = getBeginIndex();
        Map initialStyle = getAttributes();
        
        while (runStart > rangeStart) {
            AttributeMap style = fText.characterStyleAt(runStart-1);
            if (!matcher.matches(initialStyle, style, query)) {
                return runStart;
            }
            runStart = fText.characterStyleStart(runStart-1);
        }
        return rangeStart;
    }
    
    /**
     * Returns the index of the first character following the run
     * with respect to all attributes containing the current character.
     */
    public int getRunLimit() {
        return fStyleCache.getRunLimit(fCharIter.getIndex());
    }

    /**
     * Returns the index of the first character following the run
     * with respect to the given attribute containing the current character.
     */
    public int getRunLimit(Object attribute) {
        
        return getRunLimit(attribute, ATTR_MATCHER);
    }

    /**
     * Returns the index of the first character following the run
     * with respect to the given attribute containing the current character.
     */
///*JDK12IMPORTS
    public int getRunLimit(Attribute attribute) {
        
        return getRunLimit(attribute, ATTR_MATCHER);
    }
//JDK12IMPORTS*/

    /**
     * Returns the index of the first character following the run
     * with respect to the given attributes containing the current character.
     */
///*JDK12IMPORTS
    public int getRunLimit(Set attributes) {
        
        return getRunLimit(attributes, SET_MATCHER);
    }
//JDK12IMPORTS*/

    private int getRunLimit(Object query, Matcher matcher) {

        int runLimit = getRunLimit();
        int rangeLimit = getEndIndex();
        Map initialStyle = getAttributes();
        
        while (runLimit < rangeLimit) {
            AttributeMap style = fText.characterStyleAt(runLimit);
            if (!matcher.matches(initialStyle, style, query)) {
                return runLimit;
            }
            runLimit = fText.characterStyleLimit(runLimit);
        }
        return rangeLimit;
    }
    
    /**
     * Returns a map with the attributes defined on the current
     * character.
     */
    public Map getAttributes() {
        return fStyleCache.getStyle(fCharIter.getIndex());
    }

    /**
     * Returns the value of the named attribute for the current character.
     * Returns null if the attribute is not defined.
     * @param attribute the key of the attribute whose value is requested.
     */
    public Object getAttribute(Object attribute) {
        return getAttributes().get(attribute);
    }

    /**
     * Returns the value of the named attribute for the current character.
     * Returns null if the attribute is not defined.
     * @param attribute the key of the attribute whose value is requested.
     */
    public Object getAttribute(Attribute attribute) {
        return getAttributes().get(attribute);
    }

    /**
     * Returns the keys of all attributes defined on the
     * iterator's text range. The set is empty if no
     * attributes are defined.
     */
///*JDK12IMPORTS
    public Set getAllAttributeKeys() {
        throw new Error("Implement this method!");
    }
//JDK12IMPORTS*/

    public Object clone() {
        return new MTextIterator(fText,
                                 fFontResolver,
                                 getBeginIndex(),
                                 getEndIndex());
    }
}