package org.apache.archiva.redback.components.modello.jpox.metadata;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

import org.codehaus.modello.ModelloException;
import org.codehaus.modello.metadata.AbstractMetadataPlugin;
import org.codehaus.modello.metadata.AssociationMetadata;
import org.codehaus.modello.metadata.ClassMetadata;
import org.codehaus.modello.metadata.FieldMetadata;
import org.codehaus.modello.metadata.InterfaceMetadata;
import org.codehaus.modello.metadata.ModelMetadata;
import org.codehaus.modello.model.Model;
import org.codehaus.modello.model.ModelAssociation;
import org.codehaus.modello.model.ModelClass;
import org.codehaus.modello.model.ModelField;
import org.codehaus.modello.model.ModelInterface;
import org.codehaus.plexus.util.StringUtils;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * @author <a href="mailto:evenisse@codehaus.org">Emmanuel Venisse</a>
 * @version $Id: JPoxMetadataPlugin.java 829 2007-03-22 14:32:42Z joakime $
 */
public class JPoxMetadataPlugin extends AbstractMetadataPlugin
{
    public static final String ENABLED = "jpox.enabled";

    public static final String DEPENDENT = "jpox.dependent";

    public static final String DETACHABLE = "jpox.detachable";

    public static final String FETCH_GROUPS = "jpox.fetch-groups";

    public static final String NOT_PERSISTED_FIELDS = "jpox.not-persisted-fields";

    public static final String JOIN = "jpox.join";

    public static final String MAPPED_BY = "jpox.mapped-by";

    public static final String NULL_VALUE = "jpox.null-value";

    public static final String TABLE = "jpox.table";

    public static final String TABLE_PREFIX = "jpox.table-prefix";

    public static final String COLUMN = "jpox.column";

    public static final String COLUMN_PREFIX = "jpox.column-prefix";

    public static final String RESERVED_WORD_STRICTNESS = "jpox.reserved-word-strictness";

    public static final String MAPPING_IN_PACKAGE = "jpox.mapping-in-package";

    public static final String JOIN_TABLE = "jpox.join-table";

    public static final String INDEXED = "jpox.indexed";

    public static final String PRIMARY_KEY = "jpox.primary-key";

    public static final String UNIQUE = "jpox.unique";

    public static final String FOREIGN_KEY_DEFERRED = "jpox.foreign-key-deferred";

    public static final String FOREIGN_KEY_DELETE_ACTION = "jpox.foreign-key-delete-action";

    public static final String FOREIGN_KEY_UPDATE_ACTION = "jpox.foreign-key-update-action";

    public static final String VALUE_STRATEGY = "jpox.value-strategy";

    public static final String PERSISTENCE_MODIFIER = "jpox.persistence-modifier";

    public static final String IDENTITY_TYPE = "jpox.identity-type";

    public static final String IDENTITY_CLASS = "jpox.identity-class";

    public static final String USE_IDENTIFIERS = "jpox.use-identifiers-as-primary-key";

    // ----------------------------------------------------------------------
    // Map to Metadata
    // ----------------------------------------------------------------------

    public ModelMetadata getModelMetadata( Model model, Map data )
    {
        JPoxModelMetadata metadata = new JPoxModelMetadata();

        String columnPrefix = (String) data.get( COLUMN_PREFIX );

        if ( StringUtils.isNotEmpty( columnPrefix ) )
        {
            metadata.setColumnPrefix( columnPrefix );
        }

        String tablePrefix = (String) data.get( TABLE_PREFIX );

        if ( StringUtils.isNotEmpty( tablePrefix ) )
        {
            metadata.setTablePrefix( tablePrefix );
        }

        metadata.setMappingInPackage( getBoolean( data, MAPPING_IN_PACKAGE, false ) );

        String reservedWordStrictness = (String) data.get( RESERVED_WORD_STRICTNESS );

        // Set default.
        metadata.setReservedWordStrictness( JPoxModelMetadata.WARNING );

        // Set based on provided.
        if ( StringUtils.isNotEmpty( reservedWordStrictness ) )
        {
            if ( JPoxModelMetadata.ERROR.equalsIgnoreCase( reservedWordStrictness ) )
            {
                metadata.setReservedWordStrictness( JPoxModelMetadata.ERROR );
            }
            else if ( JPoxModelMetadata.WARNING.equalsIgnoreCase( reservedWordStrictness ) )
            {
                metadata.setReservedWordStrictness( JPoxModelMetadata.WARNING );
            }
            else
            {
                getLogger().warn(
                                  "Unknown reserved word strictness value: '" + reservedWordStrictness + "'.  "
                                                  + "Only '" + JPoxModelMetadata.ERROR + "' and '"
                                                  + JPoxModelMetadata.WARNING
                                                  + "' are acceptable inputs.  Defaulting to 'warning'." );
            }
        }

        return metadata;
    }

    public InterfaceMetadata getInterfaceMetadata( ModelInterface modelInterface, Map<String, String> stringStringMap )
        throws ModelloException
    {
        // TODO to implemens ?
        return null;
    }

    public ClassMetadata getClassMetadata( ModelClass clazz, Map data ) throws ModelloException
    {
        JPoxClassMetadata metadata = new JPoxClassMetadata();

        metadata.setEnabled( getBoolean( data, ENABLED, true ) );
        metadata.setDetachable( getBoolean( data, DETACHABLE, true ) );

        String notPersistedFields = (String) data.get( NOT_PERSISTED_FIELDS );

        if ( !StringUtils.isEmpty( notPersistedFields ) )
        {
            List ignoredFields = Arrays.asList( StringUtils.split( notPersistedFields ) );

            metadata.setNotPersisted( ignoredFields );
        }

        String table = (String) data.get( TABLE );

        if ( !StringUtils.isEmpty( table ) )
        {
            metadata.setTable( table );
        }

        String columnPrefix = (String) data.get( COLUMN_PREFIX );

        if ( !StringUtils.isEmpty( columnPrefix ) )
        {
            metadata.setColumnPrefix( columnPrefix );
        }

        String identityType = (String) data.get( IDENTITY_TYPE );

        if ( StringUtils.isNotEmpty( identityType ) )
        {
            metadata.setIdentityType( identityType );
        }

        String identityClass = (String) data.get( IDENTITY_CLASS );

        if ( StringUtils.isNotEmpty( identityClass ) )
        {
            metadata.setIdentityClass( identityClass );
        }

        metadata.setUseIdentifiersAsPrimaryKey( getBoolean( data, USE_IDENTIFIERS, true ) );

        return metadata;
    }

    public FieldMetadata getFieldMetadata( ModelField field, Map data ) throws ModelloException
    {
        JPoxFieldMetadata metadata = new JPoxFieldMetadata();

        JPoxClassMetadata classMetadata = (JPoxClassMetadata) field.getModelClass().getMetadata( JPoxClassMetadata.ID );

        boolean useIdentifiersAsPrimaryKey = classMetadata.useIdentifiersAsPrimaryKey();

        metadata.setPrimaryKey( getBoolean( data, PRIMARY_KEY, ( field.isIdentifier() && useIdentifiersAsPrimaryKey ) ) );

        // Backwards Compatibility Syntax.
        String fetchGroupNames = (String) data.get( "jpox.fetchGroupNames" );

        if ( fetchGroupNames != null )
        {
            getLogger().warn(
                              "You are using the <field jpox.fetchGroupNames=\"\"> attribute syntax.  "
                                              + "It has been deprecated in favor of the <field jpox.fetch-groups=\"\"> syntax instead." );
        }
        else
        {
            // Correct Syntax.
            fetchGroupNames = (String) data.get( FETCH_GROUPS );
        }

        if ( !StringUtils.isEmpty( fetchGroupNames ) )
        {
            List fetchGroups = Arrays.asList( StringUtils.split( fetchGroupNames ) );

            metadata.setFetchGroupNames( fetchGroups );
        }

        // Backwards Compatibility Syntax.
        String mappedBy = (String) data.get( "jpox.mappedBy" );

        if ( mappedBy != null )
        {
            getLogger().warn(
                              "You are using the <field jpox.mappedBy=\"\"> attribute syntax.  "
                                              + "It has been deprecated in favor of the <field jpox.mapped-by=\"\"> syntax instead." );
        }
        else
        {
            // Correct Syntax.
            mappedBy = (String) data.get( MAPPED_BY );
        }

        if ( !StringUtils.isEmpty( mappedBy ) )
        {
            metadata.setMappedBy( mappedBy );
        }

        // Backwards Compatibility Syntax.
        String nullValue = (String) data.get( "jpox.nullValue" );

        if ( nullValue != null )
        {
            getLogger().warn(
                              "You are using the <field jpox.nullValue=\"\"> attribute syntax.  "
                                              + "It has been deprecated in favor of the <field jpox.null-value=\"\"> syntax instead." );
        }
        else
        {
            // Correct Syntax.
            nullValue = (String) data.get( NULL_VALUE );
        }

        if ( !StringUtils.isEmpty( nullValue ) )
        {
            metadata.setNullValue( nullValue );
        }

        String column = (String) data.get( COLUMN );

        if ( StringUtils.isNotEmpty( column ) )
        {
            metadata.setColumnName( column );
        }

        String joinTable = (String) data.get( JOIN_TABLE );

        if ( StringUtils.isNotEmpty( joinTable ) )
        {
            metadata.setJoinTableName( joinTable );
        }

        String indexed = (String) data.get( INDEXED );

        if ( StringUtils.isNotEmpty( indexed ) )
        {
            metadata.setIndexed( indexed );
        }

        String persistenceModifier = (String) data.get( PERSISTENCE_MODIFIER );

        if ( StringUtils.isNotEmpty( persistenceModifier ) )
        {
            metadata.setPersistenceModifier( persistenceModifier );
        }

        // According to http://www.jpox.org/docs/1_1/identity_generation.html the default value for
        // this should be 'native', however this is untrue in jpox-1.1.1
        metadata.setValueStrategy( "native" );

        if ( StringUtils.isNotEmpty( (String) data.get( VALUE_STRATEGY ) ) )
        {
            String valueStrategy = (String) data.get( VALUE_STRATEGY );

            if ( StringUtils.equals( valueStrategy, "off" ) )
            {
                metadata.setValueStrategy( null );
            }
            else
            {
                metadata.setValueStrategy( valueStrategy );
            }
        }

        metadata.setUnique( getBoolean( data, UNIQUE, false ) );
        metadata.setForeignKey( getBoolean( data, FOREIGN_KEY_DEFERRED, false ) );
        metadata.setForeignKeyDeferred( getEnumString( data, FOREIGN_KEY_DEFERRED, JPoxFieldMetadata.BOOLEANS, null ) );
        metadata.setForeignKeyDeleteAction( getEnumString( data, FOREIGN_KEY_DELETE_ACTION,
                                                           JPoxFieldMetadata.FOREIGN_KEY_ACTIONS, null ) );
        metadata.setForeignKeyUpdateAction( getEnumString( data, FOREIGN_KEY_UPDATE_ACTION,
                                                           JPoxFieldMetadata.FOREIGN_KEY_ACTIONS, null ) );

        return metadata;
    }

    public AssociationMetadata getAssociationMetadata( ModelAssociation association, Map data ) throws ModelloException
    {
        JPoxAssociationMetadata metadata = new JPoxAssociationMetadata();

        metadata.setDependent( getBoolean( data, DEPENDENT, true ) );

        metadata.setJoin( getBoolean( data, JOIN, true ) );

        return metadata;
    }

    protected String getString( Map data, String key, String defaultValue )
    {
        String value = (String) data.get( key );

        if ( StringUtils.isEmpty( value ) )
        {
            return defaultValue;
        }

        return value;
    }

    protected String getEnumString( Map data, String key, String[] legalValues, String defaultValue )
        throws ModelloException
    {
        String value = (String) data.get( key );

        if ( StringUtils.isEmpty( value ) )
        {
            return defaultValue;
        }

        for ( int i = 0; i < legalValues.length; i++ )
        {
            String enumString = legalValues[i];
            if ( StringUtils.equals( enumString, value ) )
            {
                return value;
            }
        }

        String emsg = "Unknown " + key + " value: '" + value + "'.  " + "(Allowed values: " + legalValues + ")";
        throw new ModelloException( emsg );
    }

    // ----------------------------------------------------------------------
    // Metadata to Map
    // ----------------------------------------------------------------------

    public Map getFieldMap( ModelField field, FieldMetadata metadata )
    {
        return Collections.EMPTY_MAP;
    }
}