package org.litesoft.GWT.client;

import org.litesoft.core.util.*;

/**
 * Window Name is the name of the window.
 * <p/>
 * This name cannot contain spaces or special characters, but can be quite long (on the order of 2MB).
 * <p/>
 * Known good characters are US Letters (both upper & lower case), digits, and underscore ('_').
 * <p/>
 * Special / reserved Names when used as a 'target' in an 'href' (will load the document into...) are:
 * . . . _blank  . . a new blank window. This window is not named.
 * . . . _parent . . the immediate parent of the document the link is in.
 * . . . _self . . . the same window the link was clicked in (the active window).
 * . . . _top  . . . the topmost window.
 * . . . _search . . the browser's search pane. (Available in IE 5+)
 */
public class WindowName
{
    public interface Listener
    {
        public void windowNameChanged();
    }

    public static final String[] RESERVED_NAMES = //
            { //
              "_blank", //. . new blank window. This window is not named.
              "_parent", // . immediate parent of the document the link is in.
              "_self", // . . same window the link was clicked in (the active window).
              "_top", //. . . topmost window.
              "_search", // . browser's search pane. (Available in Internet Explorer 5 or later)
            };

    public static void add( Listener pListener )
    {
        if ( (pListener != null) && (-1 == indexOf( pListener )) )
        {
            sListeners = append( sListeners, pListener );
        }
    }

    public static void remove( Listener pListener )
    {
        if ( pListener != null )
        {
            int zAt = indexOf( pListener );
            if ( zAt != -1 )
            {
                sListeners = removeAt( sListeners, zAt );
            }
        }
    }

    public static void set( String pWinName )
            throws IllegalArgumentException
    {
        if ( (pWinName == null) || (pWinName.length() == 0) )
        {
            throw new IllegalArgumentException( "WinName null or empty" );
        }
        if ( -1 != pWinName.indexOf( ' ' ) )
        {
            throw new IllegalArgumentException( "WinName '" + pWinName + "' contains a space" );
        }
        if ( pWinName.charAt( 0 ) == '_' )
        {
            for ( String zReservedName : RESERVED_NAMES )
            {
                if ( zReservedName.equals( pWinName ) )
                {
                    throw new IllegalArgumentException( "WinName '" + pWinName + "' is a reserved name" );
                }
            }
        }
        if ( !pWinName.equals( get() ) )
        {
            LLset( pWinName );
            Listener[] zListeners = sListeners; // Snag the List
            for ( Listener zListener : zListeners )
            {
                zListener.windowNameChanged();
            }
        }
    }

    /**
     * @return null or a non-Empty WindowName
     */
    public static String get()
    {
        return UtilsCommon.noEmpty( LLget() );
    }

    private static native String LLget()/*-{
        return $wnd.name;
    }-*/;

    private static native void LLset( String pWinName )/*-{
        $wnd.name = pWinName;
    }-*/;

    private static Listener[] sListeners = new Listener[0];

    private static int indexOf( Listener pListener )
    {
        for ( int i = 0; i < sListeners.length; i++ )
        {
            Listener zListener = sListeners[i];
            if ( zListener == pListener ) // Identity
            {
                return i;
            }
        }
        return -1;
    }

    private static Listener[] append( Listener[] pArray, Listener pListener )
    {
        int zLength = pArray.length;
        if ( zLength == 0 )
        {
            return new Listener[]{pListener};
        }
        Listener[] zNew = new Listener[zLength + 1];
        System.arraycopy( pArray, 0, zNew, 1, zLength );
        zNew[0] = pListener;
        return zNew;
    }

    private static Listener[] removeAt( Listener[] pArray, int pIndexToRemove )
    {
        int zNewLength = pArray.length - 1;
        Listener[] zNew = new Listener[zNewLength];
        if ( pIndexToRemove != 0 )
        {
            System.arraycopy( pArray, 0, zNew, 0, pIndexToRemove );
        }
        if ( pIndexToRemove != zNewLength )
        {
            System.arraycopy( pArray, pIndexToRemove + 1, zNew, pIndexToRemove, zNewLength - pIndexToRemove );
        }
        return zNew;
    }
}