/*
 *    GeoTools - The Open Source Java GIS Toolkit
 *    http://geotools.org
 * 
 *    (C) 2004-2008, Open Source Geospatial Foundation (OSGeo)
 *    
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library 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
 *    Lesser General Public License for more details.
 */
package org.geotools.feature;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.geotools.factory.CommonFactoryFinder;
import org.geotools.factory.Hints;
import org.geotools.feature.type.AttributeDescriptorImpl;
import org.geotools.feature.type.AttributeTypeImpl;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.feature.type.AttributeDescriptor;
import org.opengis.feature.type.FeatureType;
import org.opengis.filter.Filter;
import org.opengis.filter.FilterFactory;
import org.opengis.filter.PropertyIsNull;

/**
 * This class contains utility methods focused on the schema represented by
 * the FeatureType data model.
 * <p>
 * These methods are often used for implementation the convience methods
 * such as FeatureType.getAttributeCount(), although they may be used directly
 * with any FeatureType.
 * </p>
 * <p>
 * These schema methods are based on the *complete* picture indicated by a FeatureType
 * and its ancestors. Many of these methods are focused on the derivation of AttribtueTypes
 * during an override.
 * </p>
 * @see FeatureTypes
 * @see FeatureType
 * @author Jody Garnett
 * @since 2.1.0
 * @deprecated This helper class was for the old feature model; please use FeatureTypes
 *
 *
 * @source $URL$
 */
public class Schema {
    private static Schema DEFAULT = new Schema();
    private FilterFactory ff;
    
    public Schema(){
        this( (Hints) null );
    }
    public Schema( Hints hints ){
        this( CommonFactoryFinder.getFilterFactory( hints ));
    }
    public Schema( FilterFactory filterFactory ){
        ff = filterFactory;
    }

    /**
     * Walk the provided FeatureType and produce a count of distinct attribtues.
     * <p>
     * used to detect duplicate attributes names (ie override)
     * </p>
     *  
     * @param featureType
     */
    public int getAttributeCount( SimpleFeatureType featureType ) {
        return getNames( featureType ).size();
    }
    
    /**
     * Does a quick walk to detect only a list of attribute names.
     * <p>
     * This method does not produce the complete schema (ie derrived restrictions based
     * on attribute facets). It is only used to get a list of the unique attribtues in
     * the resulting schema.
     * </p>
     * @param featureType
     * 
     * @return Set of unique attribute names
     */
    public List getNames( SimpleFeatureType featureType ) {
        return getNames( featureType, new ArrayList() );        
    }
    
        
    /**
     * This order is to be respected, based on Ancestors and so on.
     * <p>
     * This method is "faster" then actually constructing the merged
     * AttribtueTypes.
     * </p>
     */
    public List getNames( SimpleFeatureType featureType, List names ){
        if( featureType == null || featureType.getAttributeDescriptors() == null ){
            return names;
        }
        List ancestors = FeatureTypes.getAncestors(featureType);
        if( ancestors != null && !ancestors.isEmpty() ){
            for( int i=0, length = ancestors.size(); i<length; i++ ){
                SimpleFeatureType superType = (SimpleFeatureType) ancestors.get(i);
                getNames( superType, names );	           
	        }
        }
        List attributes = featureType.getAttributeDescriptors();
        if( attributes != null && !attributes.isEmpty() ){
            for( int i=0, length = attributes.size(); i<length; i++ ){
                AttributeDescriptor type = (AttributeDescriptor) attributes.get(i);
	            String name = type.getLocalName();
	            if( !names.contains( name )){
	                names.add( name );
	            }
	        }
        }
        return names;
    }

    public List getAttributes( SimpleFeatureType featureType ){
        return getAttributes( featureType, new ArrayList() );                       
    }
    
    
    /**
     * This order is to be respected, based on Ancestors and so on.
     * <p>
     * This method is "faster" then actually constructing the merged
     * AttribtueTypes.
     * </p>
     */
    public List getAttributes( SimpleFeatureType featureType, List list ){
        if( featureType == null || featureType.getAttributeDescriptors() == null ) {
            return list;
        }

        List ancestors = FeatureTypes.getAncestors(featureType);
        if( ancestors != null && !ancestors.isEmpty()){
            for( int i=0, length = ancestors.size(); i<length; i++ ){
                //eatureType type = ancestors[i];
                getAttributes( (SimpleFeatureType) ancestors.get(i), list );	           
	        }
        }
        List attributes = featureType.getAttributeDescriptors();
        if( attributes != null && !attributes.isEmpty() ){
            for( int i=0, length = attributes.size(); i<length; i++ ){
                AttributeDescriptor type = (AttributeDescriptor) attributes.get(i);
	            String name = type.getLocalName();
	            int index = getIndexOf( list, name );
	            if( index != -1 ){
	            	AttributeDescriptor origional = (AttributeDescriptor) list.get( index );
	            	list.remove( index );
	            	list.add( index, override( origional, type ));
	            }
	            else {
	            	list.add( type );
	            }
	        }
        }
        return list;
    }
    /**
     * Query featureType information the complete restrictions for the indicated name.
     * 
     * @param featureType
     * @param name
     */
    public Filter getRestrictions( SimpleFeatureType featureType, String name ){
        if( featureType == null || featureType.getAttributeDescriptors() == null ) return Filter.EXCLUDE;
        
        List restrictions = restriction( featureType, name, Collections.singletonList(Filter.INCLUDE) );
        return (Filter) restrictions.get(0);
    }
    
    /**
     * Lookup can only really be by name.
     * 
     * @param type
     */
    public int getIndexOf( SimpleFeatureType type, String name ) {
        List names = getNames( type );
        return names.indexOf( name );
    }
    
    /**
     * Look up based on name in the provided position.
     * 
     * @param type  the FeatureType
     * @param index the position
     * 
     */
    public AttributeDescriptor getAttribute( SimpleFeatureType type, int index ) {
        String name = (String) getNames( type ).get( index );
        return getXPath( type, name );
    }
    
    public AttributeDescriptor getAttribute( SimpleFeatureType type, String name ){
    	List list = getAttributes( type );
    	int index = getIndexOf( list, name );
    	if( index == -1 ) return null;
    	return (AttributeDescriptor) list.get( index );
    }

    /**
     * Look up based on name in the provided position.
     * <p>
     * AttributeType needs a xpath based access
     * </p>
     * @param type
     * @param xpath
     * 
     */
    public AttributeDescriptor getXPath( SimpleFeatureType type, String xpath) {
        return getAttribute( type, xpath ); // for now, use JXPath later
    }
    
    // Utility Methods
    //
    private int getIndexOf( List attributes, String name ){
        int index = 0;
        for( Iterator i=attributes.iterator(); i.hasNext(); index++){
            AttributeDescriptor type = (AttributeDescriptor) i.next();
            if( name.equals( type.getLocalName() )) return index;
        }
        return -1;
    }
    
    private AttributeDescriptor override(AttributeDescriptor type, AttributeDescriptor override ){
        int max = override.getMaxOccurs();
        if( max < 0 ) max = type.getMinOccurs();
        
        int min = override.getMinOccurs();
        if( min < 0 ) min = type.getMinOccurs();
        
        String name = override.getLocalName();
        if( name == null ) name = type.getLocalName();
        
        List restrictions = override( type.getType().getRestrictions(), override.getType().getRestrictions() );
        
        Class javaType = override.getType().getBinding();
        if( javaType == null ) javaType = type.getType().getBinding();
        
        boolean isNilable = override.isNillable();
        
        Object defaultValue = override.getDefaultValue();
        if( defaultValue == null ) defaultValue = type.getDefaultValue();
        
        // WARNING cannot copy metadata!        
        return new AttributeDescriptorImpl(
            new AttributeTypeImpl( new NameImpl( name ), javaType, false, false, restrictions, null, null ), 
            new NameImpl( name ), min, max, isNilable, defaultValue
        );
    }
    
    private List restriction( SimpleFeatureType featureType, String name, List filters ){
        List ancestors = FeatureTypes.getAncestors(featureType);
        if( ancestors != null && !ancestors.isEmpty()){
            for( int i=0, length = ancestors.size(); i<length; i++ ){
                SimpleFeatureType superType = (SimpleFeatureType) ancestors.get(i);
                filters = restriction( superType, name, filters );                              
            }
        }
        List attributes = featureType.getAttributeDescriptors();
        if( attributes != null && !attributes.isEmpty()){
            for( int i=0, length = attributes.size(); i<length; i++ ){
                AttributeDescriptor type = (AttributeDescriptor) attributes.get(i);
                if( name.equals( type.getLocalName() )){
                    filters = override( filters, type.getType().getRestrictions() );                 
                }
            }
        }
        return filters;
    }
    
    private List override ( List filters, List overrides ){
        if ( filters.size() != overrides.size() ) {
            throw new IllegalArgumentException( "filters not same size");
        }
        
        List result = new ArrayList();
        for ( int i = 0; i < filters.size(); i++ ) {
            Filter f = override( (Filter) filters.get(i), (Filter) overrides.get(i) );
        }
        
        return result;
    }
    
    private Filter override( Filter filter, Filter override ){
        if( isNOP( override )){
            // no override is needed
            return filter;
        }
        else if( isNOP( filter )){
            return override;
        }
        else {            
            return ff.and( filter, override );
        }
    }
    
    private boolean isNOP( Filter filter ){
        return filter == null || filter instanceof PropertyIsNull || filter == Filter.INCLUDE;
    }
    
    // Utiltie Methods
    // (make use of DEFAULT Schema)
    //
    
    /**
     * Walk the provided FeatureType and produce a count of distinct attribtues.
     * <p>
     * used to detect duplicate attributes names (ie override)
     * </p>
     *  
     * @param featureType
     */
    public static int attributeCount( SimpleFeatureType featureType ){
        return DEFAULT.getAttributeCount(featureType);
    }    
    
    /**
     * @deprecated use getAttribute( type, index )
     */
    public static AttributeDescriptor attribute( SimpleFeatureType type, int index ) {
        return DEFAULT.getAttribute(type, index);
    }
    /** @deprecated use getAttribute( type, name ) */
    public static AttributeDescriptor attribute( SimpleFeatureType type, String name ){
        return DEFAULT.getAttribute(type, name );
    }
    /** @deprecated use getAttributes( featureType ) */
    public static List attributes( SimpleFeatureType featureType ){
        return DEFAULT.getAttributes(featureType);
    }    
    /** @deprecated use getAttributes( featureType, list ) */
    public static List attributes( SimpleFeatureType featureType, List list ){
        return DEFAULT.getAttributes(featureType, list);
    }
     
    /**
     * @deprecated please use getIndexOf( type, name )
     */
    public static int find( SimpleFeatureType type, String name ) {
        return DEFAULT.getIndexOf(type, name);
    }
    
    
    /**
     * @deprecated use getNames( featureType )
     */
    public static List names( SimpleFeatureType featureType ) {
        return DEFAULT.getNames(featureType);
    }
    
    /**
     * @deprecated use getNames( featureType, List )
     */
    public static List names( SimpleFeatureType featureType, List names ){
        return DEFAULT.getNames( featureType, names );
    }
    
    /**
     * @deprecated please use getRestriction( featureType, name )
     */
    public static Filter restriction( SimpleFeatureType featureType, String name ){
        return DEFAULT.getRestrictions(featureType, name);
    }
    
    /**
     * @deprecated use getXPath( type, xpath );
     */
    public static AttributeDescriptor xpath( SimpleFeatureType type, String xpath) {
        return DEFAULT.getAttribute( type, xpath ); // for now, use JXPath later
    }
}