/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.microedition.m2g;

import org.w3c.dom.*;

import org.w3c.dom.events.*;

import org.w3c.dom.svg.SVGElement;

import java.io.IOException;

import java.util.Hashtable;

import java.lang.ref.WeakReference;

import java.util.Vector;

import java.util.Enumeration;

import javax.microedition.m2g.*;

import com.nokia.microedition.m2g.connection.*;

import com.nokia.mj.impl.utils.Logger;

public class M2GDocument extends M2GObject

        implements Document, M2GConnectionPolicyHandler

{

    //--------------------------------------------------

    // STATIC CONSTANTS

    //--------------------------------------------------

    // Error constants

    //--------------------------------------------------

    // VARIABLES

    //--------------------------------------------------

    private M2GEventDispatcher iEventDispatcher = null;

    private ExternalResourceHandler iResourceHandler = null;

    private M2GSVGImage iImage = null;

    private M2GSVGSVGElement iRootElement = null;

    private final M2GLiveElements iLiveElements = new M2GLiveElements(true);

    private M2GConnectionPolicy iConnectionPolicy =

        M2GConnectionFactory.getDefaultPolicy();

    boolean iConnectionRight = true;

    Vector iExternalResources = new Vector();

    /** A base url from where a document was downloaded */

    String iBaseUrl;

    /** The suffix of the url from where the document was open*/

    String iSuffixUrl;

    /**

       * Observer to be notified about changes in DOM

       * @see M2GDOMChangeObserver.notifyDOMChange()

       */

    private M2GDOMChangeObserver  iDOMChangeObserver = null;

    //--------------------------------------------------

    // METHODS

    //--------------------------------------------------

    /**

     * Creates new document object. If aData is null or empty then

     * an empty document is create.

     * @param aImage Svg image

     * @param aSuffixUrl A suffix url from where a document is downloaded

     * @param aData Plain text svg data

     */

    public M2GDocument(M2GSVGImage aImage, String aBaseUrl, String aSuffixUrl,

                       String aData)

    {

        super();

        iImage      = aImage;

        iBaseUrl    = aBaseUrl;

        iSuffixUrl  = aSuffixUrl;

        setHandle(_createDocument(

                      getNativeSVGProxyHandle(),

                      aData)

                 );

        doConstruct();

    }

    /**

    * @see org.w3c.dom.Node#appendChild()

     */

    public Node appendChild(Node newChild) throws DOMException

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI, "appendChild() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        Logger.ELOG(Logger.EJavaUI, "appendChild() - exception: "

                    + /*SF*/"Cannot appendChild to a Document node."/*SF*/);

        throw new DOMException(

            DOMException.HIERARCHY_REQUEST_ERR,

            /*SF*/"Cannot appendChild to a Document node."/*SF*/);

    }

    /**

     * Appends external resource uri to internal container

     * @param aUri External resource uri

     * @return true if succeeds

       */

    boolean appendExternalResourceURI(String aUri)

    {

        boolean result = false;

        if (aUri != null && !aUri.equals(""))

        {

            synchronized (iExternalResources)

            {

                if (!iExternalResources.contains(aUri))

                {

                    iExternalResources.addElement(aUri);

                    result = true;

                }

            }

        }

        Logger.LOG(Logger.EJavaUI, Logger.EInfo, "appendExternalResourceURI() uri=" +

                   ((aUri != null) ? aUri : "null") + ", result=" + result + " - end");

        return result;

    }

    /**

     * Checks if document contains the element

     * @param id

     * @return true if document contains the element

     */

    public boolean containsElement(String id)

    {

        if (id == null || id.equals(""))

        {

            return false;

        }

        int handle = _getElementById(

                         getNativeSVGProxyHandle(),

                         getHandle(), id);

        return M2GObject.checkHandle(handle);

    }

    /**

     * Check if external resource uri exists in internal container

     * @param aUri External resource uri

     * @return true if uri exists in container

     */

    boolean containsExternalResourceURI(String aUri)

    {

        boolean result = false;

        if (aUri != null && !aUri.equals(""))

        {

            synchronized (iExternalResources)

            {

                result = iExternalResources.contains(aUri);

            }

        }

        Logger.LOG(Logger.EJavaUI, Logger.EInfo, "containsExternalResourceURI() uri=" +

                   ((aUri != null) ? aUri : "null") + ", result=" + result + " - end");

        return result;

    }

    /**

     * @see org.w3c.dom.Document#createElementNS()

     */

    public Element createElementNS(String namespaceURI, String qualifiedName)

    {

        if (namespaceURI == null || namespaceURI.equals(""))

        {

            Logger.ELOG(Logger.EJavaUI,

                        "createElementNS() exception because namespace is null. qualifiedName="

                        + qualifiedName);

            throw new NullPointerException(/*SF*/"The namespace URI is null."/*SF*/);

        }

        if (qualifiedName == null || qualifiedName.equals(""))

        {

            Logger.ELOG(Logger.EJavaUI,

                        "createElementNS() exception - " + namespaceURI + ", "

                        + qualifiedName);

            throw new NullPointerException(/*SF*/"The qualifiedName is null."/*SF*/);

        }

        // Checks element validity

        if (!M2GSVGConstants.isQualifiedElement(qualifiedName))

        {

            Logger.ELOG(Logger.EJavaUI, "createElementNS() exception - "

                        + namespaceURI + ", " + qualifiedName);

            throw new DOMException(

                DOMException.NOT_SUPPORTED_ERR,

                /*SF*/"The type of element is not supported by the implementation."/*SF*/);

        }

        // Checks namespace validity

        if (!namespaceURI.equals(M2GSVGConstants.SVG_NAMESPACE_URI))

        {

            Logger.ELOG(Logger.EJavaUI, "createElementNS() exception - "

                        + namespaceURI + ", " + qualifiedName);

            throw new DOMException(

                DOMException.NOT_SUPPORTED_ERR,

                /*SF*/"The URI is not the SVG namespace URI."/*SF*/);

        }

        // Creates native element. A native document owns the new element.

        // NOTE: The element is NOT located in the DOM tree yet.

        int elementHandle = _createElementNS(

                                getNativeSVGProxyHandle(),

                                M2GSVGConstants.parseElementTypeId(qualifiedName),

                                getHandle());

        M2GSVGLocatableElement element = null;

        // Checks native handle validity

        if (M2GObject.checkHandle(elementHandle))

        {

            // Creates java element object

            element = new M2GSVGLocatableElement(elementHandle, this);

            registerLiveElement(element, new Integer(elementHandle));

        }

        else

        {

            Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                       "createElementNS(): " + qualifiedName + " - end, NOK!!!");

        }

        return element;

    }

    /**

     * Checks document validity.

     * @return true if valid

     */

    public boolean doCheckValidity() throws IOException

    {

        boolean result = false;

        if (isHandleValid())

        {

            M2GSVGSVGElement root = getRootElement();

            if (root != null)

            {

                // Check svg version and base profile

                root.checkVersionAndProfile();

                result = true;

            }

        }

        return result;

    }

    /**

     * Cleanup

     * @see com.nokia.microedition.m2g.M2GObject#doCleanup()

     */

    public void doCleanup()

    {

        if (isHandleValid())

        {

            _deleteDocument(

                getNativeSVGProxyHandle(),

                getHandle());

        }

        iImage = null;

        if (iEventDispatcher != null)

        {

            iEventDispatcher.clear();

            iEventDispatcher = null;

        }

        resetHandles();

    }

    /**

     * @see com.nokia.microedition.m2g.M2GObject#doConstruct()

     */

    protected void doConstruct()

    {

        super.doConstruct();

        iEventDispatcher = new M2GEventDispatcher();

    }

    /**

     * Find an element from the handle-to-element map.

     * @see M2GLiveElements#findElement()

     */

    public SVGElement findLiveElement(Integer aElementHandle)

    {

        return iLiveElements.findElement(aElementHandle);

    }

    /**

     * Get connection policy

     * @see M2GConnectionListener#getConnectionPolicy()

     */

    public M2GConnectionPolicy getConnectionPolicy()

    {

        return iConnectionPolicy;

    }

    /**

     * @see org.w3c.dom.Document#getDocumentElement()

       */

    public Element getDocumentElement()

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getDocumentElement() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        return getRootElement();

    }

    /**

    * @see org.w3c.dom.Document#getElementById()

     */

    public Element getElementById(String id)

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI, "getElementById() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        if (id == null || id.equals(""))

        {

            Logger.ELOG(Logger.EJavaUI, "getElementById() - exception");

            throw new NullPointerException(/*SF*/"The ID is null."/*SF*/);

        }

        int elementHandle = _getElementById(

                                getNativeSVGProxyHandle(),

                                getHandle(),

        return M2GSVGElement.buildElement(elementHandle, this);

    }

    /**

     * Returns the image

     */

    public M2GSVGImage getImage()

    {

        return iImage;

    }

    /**

     * @see org.w3c.dom.Node#getLocalName()

     */

    public String getLocalName()

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI, "getLocalName() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        return null;

    }

    /**

    * @see org.w3c.dom.Node#getNamespaceURI()

     */

    public String getNamespaceURI()

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI, "getNamespaceURI() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        return null;

    }

    /**

     * @see org.w3c.dom.Node#getParentNode()

     */

    public Node getParentNode()

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getParentNode() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        return null;

    }

    /**

     * Get root element

     * @return M2GSVGSVGElement

       */

    public M2GSVGSVGElement getRootElement()

    {

        if (iRootElement == null)

        {

            iRootElement = M2GSVGSVGElement.buildRootElement(this);

        }

        return iRootElement;

    }

    /**

     * @see javax.microedition.m2g.ScalableImage#getViewportHeight()

     */

    public int getViewportHeight()

    {

        return _getViewportHeight(

                   getNativeSVGProxyHandle(),

                   getHandle());

    }

    /**

     * @see javax.microedition.m2g.ScalableImage#getViewportWidth()

     */

    public int getViewportWidth()

    {

        return _getViewportWidth(

                   getNativeSVGProxyHandle(),

    }

    /**

     * Called by SVGImage upon creating an Event instance

     * Calls the handleEvent() of all the listeners of the event

     */

    public void handleEvent(Event aEvent)

    {

        iEventDispatcher.handleEvent(aEvent);

    }

    /**

    * @see org.w3c.dom.Node#insertBefore()

     */

    public Node insertBefore(Node newChild, Node refChild)

    {

        // Optimization: if(!getConnectionPolicy().getAccessRight())

        if (!iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI, "insertBefore() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        Logger.ELOG(Logger.EJavaUI, "insertBefore() DOMException");

        throw new DOMException(

            DOMException.HIERARCHY_REQUEST_ERR,

            /*SF*/"Cannot insertBefore a Document node."/*SF*/);

    }

    /**

     * Checks if element is in DOM

     * @param aElementHandle -

     * @return true if element is in DOM

     */

    public boolean isElementInDOM(int aElementHandle)

    {

        if (!M2GObject.checkHandle(aElementHandle))

        {

            return false;

        }

        return (_isElementInDOM(

                    getNativeSVGProxyHandle(),

                    getHandle(),

                    aElementHandle) > 0 ? true : false);

    }

    /**

     * The external resource handler is invoked

     * for any external resource referenced in the document.

     * @param aUri External resource referenced in the document

     */

    public void invokeResourceHandler(String aUri)

    {

        Logger.LOG(Logger.EJavaUI, Logger.EInfo, "invokeResourceHandler() - URI="

                   + aUri + " - begin");

        if ((iImage != null) && (iResourceHandler != null) &&

                (aUri != null) && (aUri.length() > 4))

        {

            StringBuffer urlBuf = new StringBuffer();

            // The uri format for external resource must include the base url

            // from which the document was loaded. It's also checked that the

            // url read from svg doesn't contain already the base part.

            if ((iBaseUrl != null) &&

                    !iBaseUrl.equals("") &&

                    (aUri.indexOf(iBaseUrl) == -1))

            {

                Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                           "invokeResourceHandler() append base url=" + iBaseUrl);

                urlBuf.append(iBaseUrl);

            }

            urlBuf.append(aUri);

            // append the url suffix in case of drm open mode

            if (iSuffixUrl != null && !iSuffixUrl.equals(""))

            {

                Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                           "invokeResourceHandler() append suffix url=" + iSuffixUrl);

                urlBuf.append(iSuffixUrl);

            }

            Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                       "invokeResourceHandler() handler uri=" + urlBuf.toString());

            iResourceHandler.requestResource(iImage, urlBuf.toString());

            appendExternalResourceURI(aUri);

        }

        Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                   "invokeResourceHandler() - URI:" + aUri + " - end");

    }

    /**

     * Registers an event target and an event listener.

     * @param aTarget Target element

     * @param aType Event type

     * @param aListener Event listener

     */

    void register(EventTarget aTarget, String aType, EventListener aListener)

    {

        iEventDispatcher.register(aTarget, aType, aListener);

    }

    /**