/*   Copyright 2004 The Apache Software Foundation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.xmlbeans.impl.store;

import org.apache.xmlbeans.impl.common.ValidatorListener;
import org.apache.xmlbeans.impl.store.Splay.Attr;
import org.apache.xmlbeans.impl.store.Splay.Begin;
import org.apache.xmlbeans.impl.store.Splay.Container;
import org.apache.xmlbeans.impl.store.Splay.CopyContext;
import org.apache.xmlbeans.impl.store.Splay.Goober;
import org.apache.xmlbeans.impl.values.NamespaceManager;
import org.apache.xmlbeans.impl.values.TypeStore;
import org.apache.xmlbeans.impl.values.TypeStoreUser;
import org.apache.xmlbeans.impl.values.TypeStoreUserFactory;
import org.apache.xmlbeans.impl.values.TypeStoreVisitor;
import org.apache.xmlbeans.QNameSet;
import org.apache.xmlbeans.SchemaField;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.SchemaTypeLoader;
import org.apache.xmlbeans.XmlCursor;
import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlOptions;
import java.util.ArrayList;
import java.util.List;
import javax.xml.namespace.QName;

public final class Type extends Goober implements TypeStore
{
    Type ( Root r, SchemaType sType, Splay s )
    {
        this( r, ((TypeStoreUserFactory) sType).createTypeStoreUser(), s );
    }
    
    Type ( Root r, TypeStoreUser user, Splay s )
    {
        super( r, Splay.TYPE );
        
        assert s.peekType() == null;
        assert user != null;
        assert s.isTypeable();
        
        _user = user;
        
        set( s, 0 );

        if (user.uses_invalidate_value())
            r._cInvalidatableTypes++;

        if (user.is_child_element_order_sensitive())
            r._cElemOrderSensitiveTypes++;
        
        user.attach_store( this );
    }

    void disconnect ( Root r )
    {
        super.disconnect( r );
        
        if (_user.uses_invalidate_value())
            r._cInvalidatableTypes--;

        if (_user.is_child_element_order_sensitive())
            r._cElemOrderSensitiveTypes--;
        
        _user.disconnect_store();
    }

    //
    //
    //

    SchemaType get_schema_type ( )
    {
        return _user.get_schema_type();
    }
    
    SchemaType get_element_type ( QName eltName, QName xsiType )
    {
        return _user.get_element_type( eltName, xsiType );
    }
    
    SchemaType get_attribute_type ( QName attrName )
    {
        return _user.get_attribute_type( attrName );
    }
    
    TypeStoreUser create_element_user ( QName eltName, QName xsiType )
    {
        TypeStoreUser ret = null;
        if (getRoot()._factory != null)
            ret = getRoot()._factory.createElementUser(get_schema_type(), eltName, xsiType);

        if (ret == null)
            ret = _user.create_element_user( eltName, xsiType );

        return ret;
    }
            
    TypeStoreUser create_attribute_user( QName attrName )
    {
        TypeStoreUser ret = null;

        if (getRoot()._factory != null)
            ret = getRoot()._factory.createAttributeUser(get_schema_type(),  attrName);

        if (ret == null)
            ret = _user.create_attribute_user( attrName );

        return ret;
    }

    XmlObject getXmlObject ( )
    {
        return (XmlObject) _user;
    }

    boolean uses_invalidate_value ( )
    {
        return _user.uses_invalidate_value();
    }

    boolean is_child_element_order_sensitive ( )
    {
        return _user.is_child_element_order_sensitive();
    }

    void invalidateText ( )
    {
        if (_inhibitUserInvalidate == 0)
            _user.invalidate_value();
    }

    void invalidateNil ( )
    {
        if (_inhibitUserInvalidate == 0)
            _user.invalidate_nilvalue();
    }
    
    void invalidateElement ( Container container, Splay s )
    {
        assert s.getContainer() == container;
        
        if (_inhibitUserInvalidate > 0)
            return;

        Type containerType = container.peekType();

        if (containerType == null)
            return;

        if (!containerType.is_child_element_order_sensitive())
            return;

        containerType._user.invalidate_value();

        for ( ; ; s = s.nextSplay() )
        {
            if (s.isFinish())
            {
                assert s.getContainer() == container;
                return;
            }

            if (s.isBegin())
            {
                Type childType = s.peekType();

                if (childType != null)
                    childType._user.invalidate_element_order();

                s = s.getFinishSplay();
            }

            break;
        }
    }

    String build_text ( NamespaceManager nsm )
    {
        return _user.build_text( nsm );
    }

    boolean build_nil ( )
    {
        return _user.build_nil();
    }
    
    int validateContent ( Splay s, NamespaceManager nsm )
    {
        Root r = getRoot();
        
        assert s.isInvalid();
        assert s.isLeaf() || s.isDoc();

        String text = build_text( nsm );

        assert text != null;

        _inhibitUserInvalidate++;

        // Validating does not logically change the doc
        long oldVersion = r.getVersion();
        
        s.toggleIsInvalid(); // Prevents infinite recursion
        
        s.insertChars( 1, r, text, 0, text.length() );

        r.restoreVersion( oldVersion );
        
        _inhibitUserInvalidate--;

        return text.length();
    }
    
    void validateValue ( Splay s, NamespaceManager nsm )
    {
        Root r = getRoot();
        
        assert s.isInvalid();
        assert s.isNormalAttr();

        String text = build_text( nsm );

        assert text != null;

        // Validating does not logically change the doc
        long oldVersion = r.getVersion();
        
        _inhibitUserInvalidate++;
        
        s.toggleIsInvalid(); // Prevents infinite recursion
        
        s.setText( r, text, 0, text.length() );
        
        r.restoreVersion( oldVersion );
        
        _inhibitUserInvalidate--;
    }

    QNameSet get_element_ending_delimiters( QName qname )
    {
        return _user.get_element_ending_delimiters( qname );
    }

    //
    //
    //
    
    public boolean is_attribute ( )
    {
        return getSplay().isAttr();
    }

    public boolean validate_on_set()
    {
        return getRoot().validateOnSet();
    }

    public XmlCursor new_cursor ( )
    {
        return new Cursor( getRoot(), getSplay() );
    }

    public void validate ( ValidatorListener vEventSink )
    {
        new Saver.ValidatorSaver( getRoot(), getSplay(), 0, null, vEventSink );
    }
    
    public SchemaTypeLoader get_schematypeloader ( )
    {
        return getRoot().getSchemaTypeLoader();
    }
    
    public QName get_xsi_type ( )
    {
        Splay s = getSplay();

        assert s.isContainer() || s.isNormalAttr();

        if (s.isNormalAttr())
            return null;

        return s.getXsiTypeName( getRoot() );
    }
    
    public TypeStoreUser change_type ( SchemaType sType )
    {
        Splay s = getSplay();

        s.setType( getRoot(), sType, false );

        Type t = s.getType( getRoot() );

        assert t != null;
        
        return t._user;
    }
    
    public void invalidate_text ( )
    {
        Splay s = getSplay();

        assert s.isTypeable();

        if (s.isInvalid())
            return;
        
        _inhibitUserInvalidate++;

        s.removeContent( getRoot(), false );

        s.toggleIsInvalid();
        assert s.isInvalid();
        
        _inhibitUserInvalidate--;
    }
    
    public String fetch_text ( int whitespaceRule )
    {
        Splay s = getSplay();

        assert !s.isInvalid();
        
        if (s.isInvalid())
            throw new RuntimeException( "Can't fetch text when invalid" );

        return s.getText( getRoot(), whitespaceRule );
    }
    
    public void store_text ( String text )
    {
        _inhibitUserInvalidate++;
        getSplay().setText( getRoot(), text, 0, text.length() );
        _inhibitUserInvalidate--;
    }
    
    public int compute_flags ( )
    {
        Splay s = getSplay();
        
        assert s.isTypeable();

        if (s.isDoc())
            return 0;

        Container parentContainer = s.getContainer();

        Type parentType = parentContainer.getType( getRoot() );

        assert parentType != null;

        TypeStoreUser parentUser = parentType._user;

        if (s.isAttr())
            return parentUser.get_attributeflags( s.getName() );

        int f = parentUser.get_elementflags( s.getName() );

        if (f != -1)
            return f;

        TypeStoreVisitor visitor = parentUser.new_visitor();

        if (visitor == null)
            return 0;

        assert !parentContainer.isLeaf();
        
        for ( Splay t = parentContainer.nextSplay() ; ; t = t.nextSplay() )
        {
            switch ( t.getKind() )
            {
            case Splay.END :
                assert false;
                break;

            case Splay.BEGIN :
                visitor.visit( t.getName() );

                if (t == s)
                    return visitor.get_elementflags();

                t = t.getFinishSplay();

                break;
            }
        }
    }

    public SchemaField get_schema_field ( )
    {
        Splay s = getSplay();
        
        assert s.isTypeable();

        if (s.isDoc())
            return null;
        
        Container parentContainer = s.getContainer();

        TypeStoreUser parentUser = parentContainer.getType( getRoot() )._user;
        
        if (s.isAttr())
            return parentUser.get_attribute_field( s.getName() );

        assert s.isBegin();

        assert !parentContainer.isLeaf();
        
        TypeStoreVisitor visitor = parentUser.new_visitor();

        if (visitor == null)
            return null;

        for ( Splay t = parentContainer.nextSplay() ; ; t = t.nextSplay() )
        {
            switch ( t.getKind() )
            {
            case Splay.END :
                assert false;
                break;

            case Splay.BEGIN :
                visitor.visit( t.getName() );

                if (t == s)
                    return visitor.get_schema_field();

                t = t.getFinishSplay();

                break;
            }
        }
    }
    
    public int count_elements ( QName name )
    {
        return getRoot().count( (Container) getSplay(), name, null );
    }

    public int count_elements(QNameSet names)
    {
        return getRoot().count((Container)getSplay(),  null, names);
    }
    
    public TypeStoreUser find_element_user ( QName name, int i )
    {
        Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        Begin nthBegin = getRoot().findNthBegin( s, name, null, i );

        if (nthBegin == null)
            return null;

        Type t = nthBegin.getType( getRoot() );

        assert t != null;
        
        return t._user;
    }

    public TypeStoreUser find_element_user ( QNameSet names, int i )
    {
        Splay s = getSplay();
        assert s.isContainer();

        Begin nthBegin = getRoot().findNthBegin(s,  null, names, i);
        if (nthBegin == null) return null;

        Type t = nthBegin.getType(getRoot());
        assert t != null;

        return t._user;
    }
    
    private void findAllElementTypes ( QName name, QNameSet set, List fillMeUp )
    {
        assert getSplay().isContainer();

        Splay s = getSplay();

        if (s.isLeaf())
            return;

        loop:
        for ( s = s.nextSplay() ; ; s = s.nextSplay() )
        {
            switch ( s.getKind() )
            {
            case Splay.END  :
            case Splay.ROOT :
            {
                break loop;
            }        
            case Splay.BEGIN :
            {
                if (set == null)
                {
                    if (s.getName().equals( name ))
                    {
                        Type type = s.getType( getRoot() );

                        assert type != null;
                    
                        fillMeUp.add( type );
                    }
                }
                else
                {
                    if (set.contains(s.getName()))
                    {
                        Type type = s.getType(getRoot());
                        assert type != null;
                        fillMeUp.add(type);
                    }
                }

                s = s.getFinishSplay();
                break;
            }
            }
        }
    }

    public void find_all_element_users ( QName name, List fillMeUp )
    {
        int i = fillMeUp.size();
        
        findAllElementTypes( name, null, fillMeUp );

        for ( int j = i ; j < fillMeUp.size() ; j++ )
            fillMeUp.set( j, ((Type) fillMeUp.get( j ))._user );
    }

    public void find_all_element_users (QNameSet names, List fillMeUp)
    {
        int i = fillMeUp.size();
        findAllElementTypes(null, names, fillMeUp);

        for ( int j = i ; j < fillMeUp.size() ; j++ )
            fillMeUp.set( j, ((Type) fillMeUp.get( j ))._user );
    }

    public TypeStoreUser find_attribute_user ( QName name )
    {
        assert getSplay().isContainer();

        Splay a = getSplay().getAttr( name );

        if (a == null)
            return null;

        Type t = a.getType( getRoot() );

        assert t != null;

        return t._user;
    }
    
    public String compute_default_text ( )
    {
        Splay s = getSplay();
        
        assert s.isTypeable();

        if (s.isDoc())
            return null;

        Container parentContainer = s.getContainer();

        Type parentType = parentContainer.getType( getRoot() );

        assert parentType != null;

        TypeStoreUser parentUser = parentType._user;

        if (s.isAttr())
            return parentUser.get_default_attribute_text( s.getName() );

        String result = parentUser.get_default_element_text( s.getName() );

        if (result != null)
            return result;

        TypeStoreVisitor visitor = parentUser.new_visitor();

        if (visitor == null)
            return null;

        assert !parentContainer.isLeaf();
        
        for ( Splay t = parentContainer.nextSplay() ; ; t = t.nextSplay() )
        {
            switch ( t.getKind() )
            {
            case Splay.END :
                assert false;
                break;

            case Splay.BEGIN :
                visitor.visit( t.getName() );

                if (t == s)
                    return visitor.get_default_text();

                t = t.getFinishSplay();
                
                break;
            }
        }
    }
    
    public void invalidate_nil ( )
    {
        Splay s = getSplay();

        assert s.isTypeable();

        if (!s.isAttr())
            s.setXsiNil( getRoot(), build_nil() );
    }
      
    public boolean find_nil ( )
    {
        Splay s = getSplay();

        assert s.isTypeable();
  
        return s.isAttr() ? false : s.getXsiNil( getRoot() );
    }
    
    public String find_prefix_for_nsuri (
        String nsuri, String suggested_prefix )
    {
        Splay s = getSplay();

        if (s.isAttr())
            s = s.getContainer();

        String result = s.prefixForNamespace( getRoot(), nsuri, suggested_prefix, true);

        assert result != null;

        return result;
    }
    
    public String getNamespaceForPrefix ( String prefix )
    {
        Splay s = getSplay();

        if (s.isAttr())
            s = s.getContainer();
        
        return s.namespaceForPrefix( prefix, true );
    }

    public TypeStoreUser insert_element_user ( QName name, int i )
    {
        Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        if (i < 0)
            throw new IndexOutOfBoundsException();

        Root r = getRoot();
        Container c = (Container) s;

        Begin nthBegin = r.findNthBegin( c, name, null, i );

        if (nthBegin == null)
        {
            if (i > r.count( c, name, null ) + 1)
                throw new IndexOutOfBoundsException();

            return add_element_user( name );
        }

        return insertElement( name, nthBegin, 0 );
    }

    public TypeStoreUser insert_element_user(QNameSet set, QName name, int i)
    {
        Splay s = getSplay();

        assert s.isContainer();

        if (!s.isContainer())
            throw new IllegalStateException();

        if (i < 0)
            throw new IllegalStateException();

        Root r = getRoot();
        Container c = (Splay.Container) s;

        Begin nthBegin = r.findNthBegin(c, null, set, i);

        if (nthBegin == null)
        {
            if (i > r.count(c, null, set))
                throw new IndexOutOfBoundsException();

            return add_element_user(name);
        }

        return insertElement(name, nthBegin, 0);
    }
    
// TODO - consolidate names, this fcn is very expensive in creating names
    public TypeStoreUser add_element_user ( QName qname )
    {
        Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        Splay candidateSplay;
        int candidatePos;
            
        if (s.isLeaf())
        {
            candidateSplay = s;
            candidatePos = s.getPosLeafEnd();
        }
        else
        {
            candidateSplay = s.getFinishSplay();
            candidatePos = 0;

            QNameSet endSet = null;
            
            loop:
            for ( Splay t = candidateSplay ; ; )
            {
                for ( ; ; )
                {
                    t = t.prevSplay();
                    
                    if (t == s)
                        break loop;
                    
                    if (t.isContainer())
                        break;

                    if (t.isEnd())
                    {
                        t = t.getContainer();
                        break;
                    }
                }

                assert t.isContainer();

                if (t.getName().equals( qname ))
                    break;

                if (endSet == null)
                    endSet = get_element_ending_delimiters( qname );

                if (endSet.contains( t.getName() ))
                    candidateSplay = t;
            }
        }
        
        return insertElement( qname, candidateSplay, candidatePos );
    }

    private TypeStoreUser insertElement ( QName name, Splay s, int p )
    {
        Root r = getRoot();
        
        Begin b = new Begin( name, null );
        b.toggleIsLeaf();
        
        s.insert( r, p, b, null, 0, 0, true );
        
        Type t = b.getType( r );

        assert t != null;
        
        return t._user;
    }
    
    public void remove_element ( QName qname, int i )
    {
        if (i < 0)
            throw new IndexOutOfBoundsException();
        
        Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        if (s.isLeaf())
            throw new IndexOutOfBoundsException();

        Begin b = getRoot().findNthBegin( s, qname, null, i );

        if (b == null)
            throw new IndexOutOfBoundsException();

        b.remove( getRoot(), true );
    }

    public void remove_element(QNameSet names, int i)
    {
        if (i < 0)
            throw new IndexOutOfBoundsException();

        Splay s = getSplay();

        assert s.isContainer();

        if (!s.isContainer())
            throw new IllegalStateException();

        if (s.isLeaf())
            throw new IndexOutOfBoundsException();

        Begin b = getRoot().findNthBegin(s, null, names, i);

        if (b == null)
            throw new IndexOutOfBoundsException();

        b.remove(getRoot(), true);

    }
    
    public TypeStoreUser add_attribute_user ( QName qname )
    {
        Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        Splay a = s.getAttr( qname );

        if (a != null)
            throw new IndexOutOfBoundsException();
        
        s.nextSplay().insert(
            getRoot(), 0, a = new Attr( qname ), null, 0, 0, true );
        
        Type t = a.getType( getRoot() );

        assert t != null;

        return t._user;
    }
    
    public void remove_attribute ( QName qname )
    {
        Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        Splay a = s.getAttr( qname );

        if (a == null)
            throw new IndexOutOfBoundsException();
        
        a.remove( getRoot(), true );
    }
    
    public TypeStoreUser copy_contents_from ( TypeStore source )
    {
        assert source instanceof Type;

        Type sourceType = (Type) source;

        Splay s = getSplay();

        s.replaceContents( getRoot(), sourceType.getSplay(), sourceType.getRoot(), true, true );
        
        return s.getType( getRoot() )._user;
    }

    public void array_setter ( XmlObject[] sources, QName elementName )
    {
        // TODO - this is the quick and dirty implementation, make this faster
        
        int m = sources.length;

        ArrayList copies = new ArrayList();
        ArrayList types = new ArrayList();

        for ( int i = 0 ; i < m ; i++ )
        {
// TODO - deal with null sources[ i ] here -- what to do?

            if (sources[ i ] == null)
                throw new IllegalArgumentException( "Array element null" );
            
            else if (sources[ i ].isImmutable())
            {
                copies.add( null );
                types.add( null );
            }
            else
            {
                Type type = (Type) ((TypeStoreUser) sources[ i ]).get_store();
                
                copies.add( type.getSplay().copySplayContents( type.getRoot()));
                
                types.add( sources[ i ].schemaType() );
            }
        }

        int n = count_elements( elementName );

        for ( ; n > m ; n-- )
            remove_element( elementName, m );

        for ( ; m > n ; n++ )
            add_element_user( elementName );

        assert m == n;
        
        ArrayList elements = new ArrayList();
        
        findAllElementTypes( elementName, null, elements );

        Root r = getRoot();
        
        assert elements.size() == n;

        for ( int i = 0 ; i < n ; i++ )
        {
            Type type = (Type) elements.get( i );

            if (sources[ i ].isImmutable())
                type.getXmlObject().set( sources[ i ] );
            else
            {
                Splay s = type.getSplay();

                assert r == type.getRoot();

                assert s.isContainer();
                
                s.removeContent( r, true );
                
                CopyContext copyContext = (CopyContext) copies.get( i );

                Splay copyTree = copyContext.getTree();

                if (copyTree != null)
                {
                    char[] textCopy = copyContext.getText();

                    s.insert(
                        r, 1, copyTree, textCopy, 0, textCopy == null ? 0 : textCopy.length, true );
                }

                type.change_type( (SchemaType) types.get( i ) );
            }
        }
    }
    
    public void visit_elements ( TypeStoreVisitor visitor )
    {
       Splay s = getSplay();

        assert s.isContainer();
        
        if (!s.isContainer())
            throw new IllegalStateException();

        if (s.isLeaf())
            return;
        
        for ( s = s.nextSplay() ; ; s = s.nextSplay() )
        {
            switch ( s.getKind() )
            {
            case Splay.END :
                break;

            case Splay.BEGIN :
                visitor.visit( s.getName() );
                s = s.getFinishSplay();
                break;
            }
        }
    }

    public XmlObject[] exec_query ( String queryExpr, XmlOptions options )
        throws XmlException
    {
        return Path.query( this, queryExpr, options );
    }
    
    //
    //
    //
    
    /**
     * Returns the monitor object, used for synchronizing access to the doc.
     */
    public Object get_root_object()
    {
        return getRoot();
    }

    private final TypeStoreUser _user;
    private int _inhibitUserInvalidate;
}