/*

 * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @author Charlton Innovations, Inc.

 */

package sun.java2d.loops;

import java.util.Comparator;

import java.util.Arrays;

import sun.java2d.SunGraphics2D;

/**

 *   GraphicsComponentMgr provides services to

 *   1. register primitives for later use

 *   2. locate an instance of a primitve based on characteristics

 */

public final class GraphicsPrimitiveMgr {

    private static final boolean debugTrace = false;

    private static GraphicsPrimitive primitives[];

    private static GraphicsPrimitive generalPrimitives[];

    private static boolean needssort = true;

    private static native void initIDs(Class GP, Class ST, Class CT,

                                       Class SG2D, Class Color, Class AT,

                                       Class XORComp, Class AlphaComp,

                                       Class Path2D, Class Path2DFloat,

                                       Class SHints);

    private static native void registerNativeLoops();

    static {

        initIDs(GraphicsPrimitive.class,

                SurfaceType.class,

                CompositeType.class,

                SunGraphics2D.class,

                java.awt.Color.class,

                java.awt.geom.AffineTransform.class,

                XORComposite.class,

                java.awt.AlphaComposite.class,

                java.awt.geom.Path2D.class,

                java.awt.geom.Path2D.Float.class,

                sun.awt.SunHints.class);

        CustomComponent.register();

        GeneralRenderer.register();

        registerNativeLoops();

    }

    private static class PrimitiveSpec {

        public int uniqueID;

    }

    private static Comparator primSorter = new Comparator() {

        public int compare(Object o1, Object o2) {

            int id1 = ((GraphicsPrimitive) o1).getUniqueID();

            int id2 = ((GraphicsPrimitive) o2).getUniqueID();

            return (id1 == id2 ? 0 : (id1 < id2 ? -1 : 1));

        }

    };

    private static Comparator primFinder = new Comparator() {

        public int compare(Object o1, Object o2) {

            int id1 = ((GraphicsPrimitive) o1).getUniqueID();

            int id2 = ((PrimitiveSpec) o2).uniqueID;

            return (id1 == id2 ? 0 : (id1 < id2 ? -1 : 1));

        }

    };

    /**

     * Ensure that noone can instantiate this class.

     */

    private GraphicsPrimitiveMgr() {

    }

    public synchronized static void register(GraphicsPrimitive[] newPrimitives)

    {

        GraphicsPrimitive[] devCollection = primitives;

        int oldSize = 0;

        int newSize = newPrimitives.length;

        if (debugTrace) {

            writeLog("Registering " + newSize + " primitives");

            for (int i = 0; i < newSize; i++) {

                writeLog(newPrimitives[i].toString());

            }

        }

        if (devCollection != null) {

            oldSize = devCollection.length;

        }

        GraphicsPrimitive[] temp = new GraphicsPrimitive[oldSize + newSize];

        if (devCollection != null) {

            System.arraycopy(devCollection, 0, temp, 0, oldSize);

        }

        System.arraycopy(newPrimitives, 0, temp, oldSize, newSize);

        needssort = true;

        primitives = temp;

    }

    public synchronized static void registerGeneral(GraphicsPrimitive gen) {

        if (generalPrimitives == null) {

            generalPrimitives = new GraphicsPrimitive[] {gen};

            return;

        }

        int len = generalPrimitives.length;

        GraphicsPrimitive[] newGen = new GraphicsPrimitive[len + 1];

        System.arraycopy(generalPrimitives, 0, newGen, 0, len);

        newGen[len] = gen;

        generalPrimitives = newGen;

    }

    public synchronized static GraphicsPrimitive locate(int primTypeID,

                                                        SurfaceType dsttype)

    {

        return locate(primTypeID,

                      SurfaceType.OpaqueColor,

                      CompositeType.Src,

                      dsttype);

    }

    public synchronized static GraphicsPrimitive locate(int primTypeID,

                                                        SurfaceType srctype,

                                                        CompositeType comptype,

                                                        SurfaceType dsttype)

    {

        /*

          System.out.println("Looking for:");

          System.out.println("    method: "+signature);

          System.out.println("    from:   "+srctype);

          System.out.println("    by:     "+comptype);

          System.out.println("    to:     "+dsttype);

        */

        GraphicsPrimitive prim = locatePrim(primTypeID,

                                            srctype, comptype, dsttype);

        if (prim == null) {

            //System.out.println("Trying general loop");

            prim = locateGeneral(primTypeID);

            if (prim != null) {

                prim = prim.makePrimitive(srctype, comptype, dsttype);

                if (prim != null && GraphicsPrimitive.traceflags != 0) {

                    prim = prim.traceWrap();

                }

            }

        }

        return prim;

    }

    public synchronized static GraphicsPrimitive

        locatePrim(int primTypeID,

                   SurfaceType srctype,

                   CompositeType comptype,

                   SurfaceType dsttype)

    {

        /*

          System.out.println("Looking for:");

          System.out.println("    method: "+signature);

          System.out.println("    from:   "+srctype);

          System.out.println("    by:     "+comptype);

          System.out.println("    to:     "+dsttype);

        */

        SurfaceType src, dst;

        CompositeType cmp;

        GraphicsPrimitive prim;

        PrimitiveSpec spec = new PrimitiveSpec();

        for (dst = dsttype; dst != null; dst = dst.getSuperType()) {

            for (src = srctype; src != null; src = src.getSuperType()) {

                for (cmp = comptype; cmp != null; cmp = cmp.getSuperType()) {

                    /*

                      System.out.println("Trying:");

                      System.out.println("    method: "+spec.methodSignature);

                      System.out.println("    from:   "+spec.sourceType);

                      System.out.println("    by:     "+spec.compType);

                      System.out.println("    to:     "+spec.destType);

                    */

                    spec.uniqueID =

                        GraphicsPrimitive.makeUniqueID(primTypeID, src, cmp, dst);

                    prim = locate(spec);

                    if (prim != null) {

                        //System.out.println("<GPMgr> Found: " + prim + " in " + i + " steps");

                        return prim;

                    }

                }

            }

        }

        return null;

    }

    private static GraphicsPrimitive locateGeneral(int primTypeID) {

        if (generalPrimitives == null) {

            return null;

        }

        for (int i = 0; i < generalPrimitives.length; i++) {

            GraphicsPrimitive prim = generalPrimitives[i];

            if (prim.getPrimTypeID() == primTypeID) {

                return prim;

            }

        }

        return null;

        //throw new InternalError("No general handler registered for"+signature);

    }

    private static GraphicsPrimitive locate(PrimitiveSpec spec) {

        if (needssort) {

            if (GraphicsPrimitive.traceflags != 0) {

                for (int i = 0; i < primitives.length; i++) {

                    primitives[i] = primitives[i].traceWrap();

                }

            }

            Arrays.sort(primitives, primSorter);

            needssort = false;

        }

        GraphicsPrimitive[] devCollection = primitives;

        if (devCollection == null) {

            return null;

        }

        int index = Arrays.binarySearch(devCollection, spec, primFinder);

        if (index >= 0) {

            GraphicsPrimitive prim = devCollection[index];

            if (prim instanceof GraphicsPrimitiveProxy) {

                prim = ((GraphicsPrimitiveProxy) prim).instantiate();

                devCollection[index] = prim;

                if (debugTrace) {

                    writeLog("Instantiated graphics primitive " + prim);

                }

            }

            if (debugTrace) {

                writeLog("Lookup found[" + index + "]["+ prim + "]");

            }

            return prim;

        }

        if (debugTrace) {

            writeLog("Lookup found nothing for:");

            writeLog(" " + spec.uniqueID);

        }

        return null;

    }

    private static void writeLog(String str) {

        if (debugTrace) {

            System.err.println(str);

        }

    }

    /**

     * Test that all of the GraphicsPrimitiveProxy objects actually

     * resolve to something.  Throws a RuntimeException if anything

     * is wrong, an has no effect if all is well.

     */

    // This is only really meant to be called from GraphicsPrimitiveProxyTest

    // in the regression tests directory, but it has to be here because

    // it needs access to a private data structure.  It is not very

    // big, though.

    public static void testPrimitiveInstantiation() {

        testPrimitiveInstantiation(false);

    }

    public static void testPrimitiveInstantiation(boolean verbose) {

        int resolved = 0;

        int unresolved = 0;

        GraphicsPrimitive[] prims = primitives;

        for (int j = 0; j < prims.length; j++) {

            GraphicsPrimitive p = prims[j];

            if (p instanceof GraphicsPrimitiveProxy) {

                GraphicsPrimitive r = ((GraphicsPrimitiveProxy) p).instantiate();

                if (!r.getSignature().equals(p.getSignature()) ||

                    r.getUniqueID() != p.getUniqueID()) {

                    System.out.println("r.getSignature == "+r.getSignature());

                    System.out.println("r.getUniqueID == " + r.getUniqueID());

                    System.out.println("p.getSignature == "+p.getSignature());

                    System.out.println("p.getUniqueID == " + p.getUniqueID());

                    throw new RuntimeException("Primitive " + p

                                               + " returns wrong signature for "

                                               + r.getClass());

                }

                // instantiate checks that p.satisfiesSameAs(r)

                unresolved++;

                p = r;

                if (verbose) {

                    System.out.println(p);

                }

            } else {

                if (verbose) {

                    System.out.println(p + " (not proxied).");

                }

                resolved++;

            }

        }

        System.out.println(resolved+

                           " graphics primitives were not proxied.");

        System.out.println(unresolved+

                           " proxied graphics primitives resolved correctly.");

        System.out.println(resolved+unresolved+

                           " total graphics primitives");

    }

    public static void main(String argv[]) {

        // REMIND: Should trigger loading of platform primitives somehow...

        if (needssort) {

            Arrays.sort(primitives, primSorter);

            needssort = false;

        }

        testPrimitiveInstantiation(argv.length > 0);

    }

}