/*

 * Copyright (c) 2005, 2018, 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.

 */

package com.sun.java.accessibility.internal;

import java.awt.*;

import java.awt.event.*;

import java.util.*;

import java.lang.*;

import java.lang.reflect.*;

import java.beans.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.text.*;

import javax.swing.tree.*;

import javax.swing.table.*;

import javax.swing.plaf.TreeUI;

import javax.accessibility.*;

import com.sun.java.accessibility.util.*;

import java.awt.geom.Rectangle2D;

import sun.awt.AWTAccessor;

import sun.awt.AppContext;

import sun.awt.SunToolkit;

import java.util.concurrent.Callable;

import java.util.concurrent.ConcurrentHashMap;

/*

 * Note: This class has to be public.  It's loaded from the VM like this:

 *       Class.forName(atName).newInstance();

 */

final public class AccessBridge {

    private static AccessBridge theAccessBridge;

    private ObjectReferences references;

    private EventHandler eventHandler;

    // Maps AccessibleRoles strings to AccessibleRoles.

    private ConcurrentHashMap<String,AccessibleRole> accessibleRoleMap = new ConcurrentHashMap<>();

    /**

       If the object's role is in the following array getVirtualAccessibleName

       will use the extended search algorithm.

    */

    private ArrayList<AccessibleRole> extendedVirtualNameSearchRoles = new ArrayList<>();

    /**

       If the role of the object's parent is in the following array

       getVirtualAccessibleName will NOT use the extended search

       algorithm even if the object's role is in the

       extendedVirtualNameSearchRoles array.

    */

    private ArrayList<AccessibleRole> noExtendedVirtualNameSearchParentRoles = new ArrayList<>();

    private static native boolean isSysWow();

    /**

     * Load DLLs

     */

    static {

        // Load the appropriate DLLs

        boolean is32on64 = false;

        if (System.getProperty("os.arch").equals("x86")) {

            // 32 bit JRE

            // Load jabsysinfo.dll so can determine Win bitness

            java.security.AccessController.doPrivileged(

                new java.security.PrivilegedAction<Void>() {

                    public Void run() {

                        System.loadLibrary("jabsysinfo");

                        return null;

                    }

                }, null, new java.lang.RuntimePermission("loadLibrary.jabsysinfo")

            );

            if (isSysWow()) {

                // 32 bit JRE on 64 bit OS

                is32on64 = true;

                java.security.AccessController.doPrivileged(

                    new java.security.PrivilegedAction<Void>() {

                        public Void run() {

                            System.loadLibrary("javaaccessbridge-32");

                            return null;

                        }

                    }, null, new java.lang.RuntimePermission("loadLibrary.javaaccessbridge-32")

                );

            }

        }

        if (!is32on64) {

            // 32 bit JRE on 32 bit OS or 64 bit JRE on 64 bit OS

            java.security.AccessController.doPrivileged(

                new java.security.PrivilegedAction<Void>() {

                    public Void run() {

                        System.loadLibrary("javaaccessbridge");

                        return null;

                    }

                }, null, new java.lang.RuntimePermission("loadLibrary.javaaccessbridge")

            );

        }

    }

    /**

     * AccessBridge constructor

     *

     * Note: This constructor has to be public.  It's called from the VM like this:

     *       Class.forName(atName).newInstance();

     */

    public AccessBridge() {

        theAccessBridge = this;

        references = new ObjectReferences();

        // initialize shutdown hook

        Runtime runTime = Runtime.getRuntime();

        shutdownHook hook = new shutdownHook();

        runTime.addShutdownHook(new Thread(hook));

        // initialize AccessibleRole map

        initAccessibleRoleMap();

        // initialize the methods that map HWNDs and Java top-level

        // windows

        initHWNDcalls();

        // is this a JVM we can use?

        // install JDK 1.2 and later Swing ToolKit listener

        EventQueueMonitor.isGUIInitialized();

        // start the Java event handler

        eventHandler = new EventHandler(this);

        // register for menu selection events

        MenuSelectionManager.defaultManager().addChangeListener(eventHandler);

        // register as a NativeWindowHandler

        addNativeWindowHandler(new DefaultNativeWindowHandler());

        // start in a new thread

        Thread abthread = new Thread(new dllRunner());

        abthread.setDaemon(true);

        abthread.start();

        debugString("[INFO]:AccessBridge started");

    }

    /*

     * adaptor to run the AccessBridge DLL

     */

    private class dllRunner implements Runnable {

        public void run() {

            runDLL();

        }

    }

    /*

     * shutdown hook

     */

    private class shutdownHook implements Runnable {

        public void run() {

            debugString("[INFO]:***** shutdownHook: shutting down...");

            javaShutdown();

        }

    }

    /*

     * Initialize the hashtable that maps Strings to AccessibleRoles.

     */

    private void initAccessibleRoleMap() {

        /*

         * Initialize the AccessibleRoles map. This code uses methods in

         * java.lang.reflect.* to build the map.

         */

        try {

            Class<?> clAccessibleRole = Class.forName ("javax.accessibility.AccessibleRole");

            if (null != clAccessibleRole) {

                AccessibleRole roleUnknown = AccessibleRole.UNKNOWN;

                Field [] fields = clAccessibleRole.getFields ();

                int i = 0;

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

                    Field f = fields [i];

                    if (javax.accessibility.AccessibleRole.class == f.getType ()) {

                        AccessibleRole nextRole = (AccessibleRole) (f.get (roleUnknown));

                        String nextRoleString = nextRole.toDisplayString (Locale.US);

                        accessibleRoleMap.put (nextRoleString, nextRole);

                    }

                }

            }

        } catch (Exception e) {}

    /*

      Build the extendedVirtualNameSearchRoles array list.

    */

    extendedVirtualNameSearchRoles.add (AccessibleRole.COMBO_BOX);

    try {

        /*

          Added in J2SE 1.4

        */

        extendedVirtualNameSearchRoles.add (AccessibleRole.DATE_EDITOR);

    } catch (NoSuchFieldError e) {}

    extendedVirtualNameSearchRoles.add (AccessibleRole.LIST);

    extendedVirtualNameSearchRoles.add (AccessibleRole.PASSWORD_TEXT);

    extendedVirtualNameSearchRoles.add (AccessibleRole.SLIDER);

    try {

        /*

          Added in J2SE 1.3

        */

        extendedVirtualNameSearchRoles.add (AccessibleRole.SPIN_BOX);

    } catch (NoSuchFieldError e) {}

    extendedVirtualNameSearchRoles.add (AccessibleRole.TABLE);

    extendedVirtualNameSearchRoles.add (AccessibleRole.TEXT);

    extendedVirtualNameSearchRoles.add (AccessibleRole.UNKNOWN);

    noExtendedVirtualNameSearchParentRoles.add (AccessibleRole.TABLE);

    noExtendedVirtualNameSearchParentRoles.add (AccessibleRole.TOOL_BAR);

    }

    /**

     * start the AccessBridge DLL running in its own thread

     */

    private native void runDLL();

    /**

     * debugging output (goes to OutputDebugStr())

     */

    private native void sendDebugString(String debugStr);

    /**

     * debugging output (goes to OutputDebugStr())

     */

    private void debugString(String debugStr) {

    sendDebugString(debugStr);

    }

    /* ===== utility methods ===== */

    /**

     * decrement the reference to the object (called by native code)

     */

    private void decrementReference(Object o) {

    references.decrement(o);

    }

    /**

     * get the java.version property from the JVM

     */

    private String getJavaVersionProperty() {

        String s = System.getProperty("java.version");

        if (s != null) {

            references.increment(s);

            return s;

        }

        return null;

    }

    /* ===== HWND/Java window mapping methods ===== */

    // Java toolkit methods for mapping HWNDs to Java components

    private Method javaGetComponentFromNativeWindowHandleMethod;

    private Method javaGetNativeWindowHandleFromComponentMethod;

    // native jawt methods for mapping HWNDs to Java components

    private native int jawtGetNativeWindowHandleFromComponent(Component comp);

    private native Component jawtGetComponentFromNativeWindowHandle(int handle);

    Toolkit toolkit;

    /**

     * map an HWND to an AWT Component

     */

    private void initHWNDcalls() {

        Class<?>[] integerParemter = new Class<?>[1];

        integerParemter[0] = Integer.TYPE;

        Class<?>[] componentParemter = new Class<?>[1];

        try {

            componentParemter[0] = Class.forName("java.awt.Component");

        } catch (ClassNotFoundException e) {

            debugString("[ERROR]:Exception: " + e.toString());

        }

        toolkit = Toolkit.getDefaultToolkit();

        return;

    }

    // native window handler interface

    private interface NativeWindowHandler {

        public Accessible getAccessibleFromNativeWindowHandle(int nativeHandle);

    }

    // hash table of native window handle to AccessibleContext mappings

    static private ConcurrentHashMap<Integer,AccessibleContext> windowHandleToContextMap = new ConcurrentHashMap<>();

    // hash table of AccessibleContext to native window handle mappings

    static private ConcurrentHashMap<AccessibleContext,Integer> contextToWindowHandleMap = new ConcurrentHashMap<>();

    /*

     * adds a virtual window handler to our hash tables

     */

    static private void registerVirtualFrame(final Accessible a,

                                             Integer nativeWindowHandle ) {

        if (a != null) {

            AccessibleContext ac = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {

                @Override

                public AccessibleContext call() throws Exception {

                    return a.getAccessibleContext();

                }

            }, a);

            windowHandleToContextMap.put(nativeWindowHandle, ac);

            contextToWindowHandleMap.put(ac, nativeWindowHandle);

        }

    }

    /*

     * removes a virtual window handler to our hash tables

     */

    static private void revokeVirtualFrame(final Accessible a,

                                           Integer nativeWindowHandle ) {

        AccessibleContext ac = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {

            @Override

            public AccessibleContext call() throws Exception {

                return a.getAccessibleContext();

            }

        }, a);

        windowHandleToContextMap.remove(nativeWindowHandle);

        contextToWindowHandleMap.remove(ac);

    }

    // vector of native window handlers

    private static Vector<NativeWindowHandler> nativeWindowHandlers = new Vector<>();

    /*

    * adds a native window handler to our list

    */

    private static void addNativeWindowHandler(NativeWindowHandler handler) {

        if (handler == null) {

            throw new IllegalArgumentException();

        }

        nativeWindowHandlers.addElement(handler);

    }

    /*

     * removes a native window handler to our list

     */

    private static boolean removeNativeWindowHandler(NativeWindowHandler handler) {

        if (handler == null) {

            throw new IllegalArgumentException();

        }

        return nativeWindowHandlers.removeElement(handler);

    }

    /**

     * verifies that a native window handle is a Java window

     */

    private boolean isJavaWindow(int nativeHandle) {

        AccessibleContext ac = getContextFromNativeWindowHandle(nativeHandle);

        if (ac != null) {

            saveContextToWindowHandleMapping(ac, nativeHandle);

            return true;

        }

        return false;

    }

    /*

     * saves the mapping between an AccessibleContext and a window handle

     */

    private void saveContextToWindowHandleMapping(AccessibleContext ac,

                                                  int nativeHandle) {

        debugString("[INFO]:saveContextToWindowHandleMapping...");

        if (ac == null) {

            return;

        }

        if (! contextToWindowHandleMap.containsKey(ac)) {

            debugString("[INFO]: saveContextToWindowHandleMapping: ac = "+ac+"; handle = "+nativeHandle);

            contextToWindowHandleMap.put(ac, nativeHandle);

        }

    }

    /**

     * maps a native window handle to an Accessible Context

     */

    private AccessibleContext getContextFromNativeWindowHandle(int nativeHandle) {

        // First, look for the Accessible in our hash table of

        // virtual window handles.

        AccessibleContext ac = windowHandleToContextMap.get(nativeHandle);

        if(ac!=null) {

            saveContextToWindowHandleMapping(ac, nativeHandle);

            return ac;

        }

        // Next, look for the native window handle in our vector

        // of native window handles.

        int numHandlers = nativeWindowHandlers.size();

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

            NativeWindowHandler nextHandler = nativeWindowHandlers.elementAt(i);

            final Accessible a = nextHandler.getAccessibleFromNativeWindowHandle(nativeHandle);

            if (a != null) {

                ac = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {

                    @Override

                    public AccessibleContext call() throws Exception {

                        return a.getAccessibleContext();

                    }

                }, a);

                saveContextToWindowHandleMapping(ac, nativeHandle);

                return ac;

            }

        }

        // Not found.

        return null;

    }

    /**

     * maps an AccessibleContext to a native window handle

     *     returns 0 on error

     */

    private int getNativeWindowHandleFromContext(AccessibleContext ac) {

    debugString("[INFO]: getNativeWindowHandleFromContext: ac = "+ac);

        try {

            return contextToWindowHandleMap.get(ac);

        } catch (Exception ex) {

            return 0;

        }

    }

    private class DefaultNativeWindowHandler implements NativeWindowHandler {

        /*

        * returns the Accessible associated with a native window

        */

        public Accessible getAccessibleFromNativeWindowHandle(int nativeHandle) {

            final Component c = jawtGetComponentFromNativeWindowHandle(nativeHandle);

            if (c instanceof Accessible) {

                AccessibleContext ac = InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {

                    @Override

                    public AccessibleContext call() throws Exception {

                        return c.getAccessibleContext();

                    }

                }, c);

                saveContextToWindowHandleMapping(ac, nativeHandle);

                return (Accessible)c;

            } else {

                return null;

            }

        }

    }

    /* ===== AccessibleContext methods =====*/

    /*

     * returns the inner-most AccessibleContext in parent at Point(x, y)

     */

    private AccessibleContext getAccessibleContextAt(int x, int y,

                                                    AccessibleContext parent) {

        if (parent == null) {

            return null;

        }

        if (windowHandleToContextMap != null &&

            windowHandleToContextMap.containsValue(getRootAccessibleContext(parent))) {

            // Path for applications that register their top-level

            // windows with the AccessBridge (e.g., StarOffice 6.1)

            return getAccessibleContextAt_1(x, y, parent);

        } else {

            // Path for applications that do not register

            // their top-level windows with the AccessBridge

            // (e.g., Swing/AWT applications)

            return getAccessibleContextAt_2(x, y, parent);

        }

    }

    /*

     * returns the root accessible context

     */

    private AccessibleContext getRootAccessibleContext(final AccessibleContext ac) {

        if (ac == null) {

            return null;

        }

        return InvocationUtils.invokeAndWait(new Callable<AccessibleContext>() {

            @Override

            public AccessibleContext call() throws Exception {

                Accessible parent = ac.getAccessibleParent();

                if (parent == null) {

                    return ac;

                }

                Accessible tmp = parent.getAccessibleContext().getAccessibleParent();

                while (tmp != null) {

                    parent = tmp;

                    tmp = parent.getAccessibleContext().getAccessibleParent();

                }

                return parent.getAccessibleContext();

            }

        }, ac);

    }

    /*

     * StarOffice version that does not use the EventQueueMonitor

     */

    private AccessibleContext getAccessibleContextAt_1(final int x, final int y,

                                                      final AccessibleContext parent) {

        debugString("[INFO]: getAccessibleContextAt_1 called");

        debugString("   -> x = " + x + " y = " + y + " parent = " + parent);

        if (parent == null) return null;

            final AccessibleComponent acmp = InvocationUtils.invokeAndWait(new Callable<AccessibleComponent>() {

                @Override

                public AccessibleComponent call() throws Exception {

                    return parent.getAccessibleComponent();

                }