/*
 * Copyright (c) 2003, 2005, Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR
 * CONTRIBUTORS 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.
 */

/*
 * (C) Copyright IBM Corp. 2003, All Rights Reserved.
 * This technology is protected by multiple US and International
 * patents. This notice and attribution to IBM may not be removed.
 */

package j2dbench.tests.text;

import java.awt.Font;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.TextLayout;
import java.text.AttributedCharacterIterator;
import java.text.AttributedString;
import java.text.Bidi;
import java.text.CharacterIterator;
import java.util.Map;

import j2dbench.Group;
import j2dbench.Result;
import j2dbench.TestEnvironment;

public abstract class TextConstructionTests extends TextTests {
    static Group constructroot;
    static Group constructtestroot;

    public static void init() {
      // don't even bother with this at all if we don't have Java2 APIs.
      if (hasGraphics2D) {
        constructroot = new Group(textroot, "construction", "Construction Benchmarks");
        constructtestroot = new Group(constructroot, "tests", "Construction Tests");

        new GVFromFontString();
        new GVFromFontChars();
        new GVFromFontCI();
        new GVFromFontGlyphs();
        new GVFromFontLayout();
        //  new GVClone(); // not public API!

        new TLFromFont();
        new TLFromMap();
        /*
        new TLFromACI();
        new TLClone();
        new TLJustify();
        new TLFromLBM();
        */
      }
    }

    public TextConstructionTests(Group parent, String nodeName, String description) {
        super(parent, nodeName, description);
    }

    public static class TCContext extends G2DContext {
        char[] chars1;
        CharacterIterator ci;
        GlyphVector gv;
        int[] glyphs;
        int flags;

        public void init(TestEnvironment env, Result results) {
            super.init(env, results);

            chars1 = new char[chars.length + 2];
            System.arraycopy(chars, 0, chars1, 1, chars.length);
            ci = new ArrayCI(chars1, 1, chars.length);
            gv = font.createGlyphVector(frc, text);
            glyphs = gv.getGlyphCodes(0, gv.getNumGlyphs(), null);
            flags = Bidi.requiresBidi(chars, 0, chars.length)
                ? Font.LAYOUT_LEFT_TO_RIGHT
                : Font.LAYOUT_RIGHT_TO_LEFT;
        }
    }

    public Context createContext() {
        return new TCContext();
    }

    public static class GVFromFontString extends TextConstructionTests {
        public GVFromFontString() {
            super(constructtestroot, "gvfromfontstring", "Call Font.createGlyphVector(FRC, String)");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final String text = tcctx.text;
            final FontRenderContext frc = tcctx.frc;
            GlyphVector gv;
            do {
                gv = font.createGlyphVector(frc, text);
            } while (--numReps >= 0);
        }
    }

    public static class GVFromFontChars extends TextConstructionTests {
        public GVFromFontChars() {
            super(constructtestroot, "gvfromfontchars", "Call Font.createGlyphVector(FRC, char[])");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final char[] chars = tcctx.chars;
            final FontRenderContext frc = tcctx.frc;
            GlyphVector gv;
            do {
                gv = font.createGlyphVector(frc, chars);
            } while (--numReps >= 0);
        }
    }

    public static class GVFromFontCI extends TextConstructionTests {
        public GVFromFontCI() {
            super(constructtestroot, "gvfromfontci", "Call Font.createGlyphVector(FRC, CharacterIterator)");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final CharacterIterator ci = tcctx.ci;
            final FontRenderContext frc = tcctx.frc;
            GlyphVector gv;
            do {
                gv = font.createGlyphVector(frc, ci);
            } while (--numReps >= 0);
        }
    }

    public static class GVFromFontGlyphs extends TextConstructionTests {
        public GVFromFontGlyphs() {
            super(constructtestroot, "gvfromfontglyphs", "Call Font.createGlyphVector(FRC, int[])");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final int[] glyphs = tcctx.glyphs;
            final FontRenderContext frc = tcctx.frc;
            GlyphVector gv;
            do {
                gv = font.createGlyphVector(frc, glyphs);
            } while (--numReps >= 0);
        }
    }

    public static class GVFromFontLayout extends TextConstructionTests {
        public GVFromFontLayout() {
            super(constructtestroot, "gvfromfontlayout", "Call Font.layoutGlyphVector(...)");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final char[] chars = tcctx.chars1;
            final int start = 1;
            final int limit = chars.length - 1;
            final FontRenderContext frc = tcctx.frc;
            final int flags = tcctx.flags;
            GlyphVector gv;
            do {
                gv = font.layoutGlyphVector(frc, chars, start, limit, flags);
            } while (--numReps >= 0);
        }
    }

    /*
     * my bad, clone is not public in GlyphVector!

    public static class GVClone extends TextConstructionTests {
        public GVClone() {
            super(constructtestroot, "gvclone", "Call GV.clone");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final GlyphVector origGV = tcctx.gv;
            GlyphVector gv;
            do {
                gv = (GlyphVector)origGV.clone();
            } while (--numReps >= 0);
        }
    }
    */

    public static class TLFromFont extends TextConstructionTests {
        public TLFromFont() {
            super(constructtestroot, "tlfromfont", "TextLayout(String, Font, FRC)");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final String text = tcctx.text;
            final FontRenderContext frc = tcctx.frc;
            TextLayout tl;
            do {
                tl = new TextLayout(text, font, frc);
            } while (--numReps >= 0);
        }
    }

    public static class TLMapContext extends G2DContext {
        Map map;

        public void init(TestEnvironment env, Result results) {
            super.init(env, results);

            map = (Map)env.getModifier(tlmapList);
        }

    }

    public static class TLFromMap extends TextConstructionTests {
        public TLFromMap() {
            super(constructtestroot, "tlfrommap", "TextLayout(String, Map, FRC)");
        }

        public Context createContext() {
            return new TLMapContext();
        }

        public void runTest(Object ctx, int numReps) {
            TLMapContext tlmctx = (TLMapContext)ctx;
            final String text = tlmctx.text;
            final FontRenderContext frc = tlmctx.frc;
            final Map map = tlmctx.map;
            TextLayout tl;
            do {
                tl = new TextLayout(text, map, frc);
            } while (--numReps >= 0);
        }
    }

    public static class ACIContext extends G2DContext {
        AttributedCharacterIterator aci;

        public void init(TestEnvironment env, Result results) {
            super.init(env, results);

            AttributedString astr = new AttributedString(text);

        }
    }

    public class TLFromACI extends TextConstructionTests {
        public TLFromACI() {
            super(constructtestroot, "tlfromaci", "TextLayout(ACI, FRC)");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final String text = tcctx.text;
            final FontRenderContext frc = tcctx.frc;
            TextLayout tl;
            do {
                tl = new TextLayout(text, font, frc);
            } while (--numReps >= 0);
        }
    }

    public class TLClone extends TextConstructionTests {
        public TLClone() {
            super(constructtestroot, "tlclone", "call TextLayout.clone()");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final String text = tcctx.text;
            final FontRenderContext frc = tcctx.frc;
            TextLayout tl;
            do {
                tl = new TextLayout(text, font, frc);
            } while (--numReps >= 0);
        }
    }

    public class TLJustify extends TextConstructionTests {
        public TLJustify() {
            super(constructtestroot, "tljustify", "call TextLayout.getJustifiedLayout(...)");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final String text = tcctx.text;
            final FontRenderContext frc = tcctx.frc;
            TextLayout tl;
            do {
                tl = new TextLayout(text, font, frc);
            } while (--numReps >= 0);
        }
    }

    public class TLFromLBM extends TextConstructionTests {
        public TLFromLBM() {
            super(constructtestroot, "tlfromlbm", "call LineBreakMeasurer.next()");
        }

        public void runTest(Object ctx, int numReps) {
            TCContext tcctx = (TCContext)ctx;
            final Font font = tcctx.font;
            final String text = tcctx.text;
            final FontRenderContext frc = tcctx.frc;
            TextLayout tl;
            do {
                tl = new TextLayout(text, font, frc);
            } while (--numReps >= 0);
        }
    }

    public static final class ArrayCI implements CharacterIterator {
        char[] chars;
        int off;
        int max;
        int pos;

        ArrayCI(char[] chars, int off, int len) {
            if (off < 0 || len < 0 || (len > 0 && (chars == null || chars.length - off < len))) {
                throw new InternalError("bad ArrayCI params");
            }
            this.chars = chars;
            this.off = off;
            this.max = off + len;
            this.pos = off;
        }

    /**
     * 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() {
            if (max > off) {
                return chars[pos = off];
            }
            return DONE;
        }

    /**
     * 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() {
            if (max > off) {
                return chars[pos = max - 1];
            }
            pos = max;
            return DONE;
        }

    /**
     * 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 pos == max ? DONE : chars[pos];
        }


    /**
     * 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() {
            if (++pos < max) {
                return chars[pos];
            }
            pos = max;
            return DONE;
        }


    /**
     * 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() {
            if (--pos >= off) {
                return chars[pos];
            }
            pos = off;
            return DONE;
        }

    /**
     * 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) {
            if (position < off || position > max) {
                throw new IllegalArgumentException("pos: " + position + " off: " + off + " len: " + (max - off));
            }
            return ((pos = position) < max) ? chars[position] : DONE;
        }

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

    /**
     * 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 max;
        }

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

    /**
     * Create a copy of this iterator
     * @return A copy of this
     */
        public Object clone() {
            try {
                return super.clone();
            }
            catch (Exception e) {
                return new InternalError();
            }
        }
    }
}