/**
 * Copyright 2005-2015 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.kuali.rice.krad.data.jpa.eclipselink;

import org.apache.commons.lang.StringUtils;
import org.eclipse.persistence.config.SessionCustomizer;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.exceptions.DescriptorException;
import org.eclipse.persistence.internal.databaseaccess.Accessor;
import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.sequencing.Sequence;
import org.eclipse.persistence.sessions.DatabaseLogin;
import org.eclipse.persistence.sessions.JNDIConnector;
import org.eclipse.persistence.sessions.Session;
import org.kuali.rice.krad.data.jpa.DisableVersioning;
import org.kuali.rice.krad.data.jpa.Filter;
import org.kuali.rice.krad.data.jpa.FilterGenerator;
import org.kuali.rice.krad.data.jpa.FilterGenerators;
import org.kuali.rice.krad.data.jpa.PortableSequenceGenerator;
import org.kuali.rice.krad.data.jpa.RemoveMapping;
import org.kuali.rice.krad.data.jpa.RemoveMappings;
import org.kuali.rice.krad.data.platform.MaxValueIncrementerFactory;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.jdbc.support.incrementer.DataFieldMaxValueIncrementer;

import javax.sql.DataSource;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * EclipseLink Session Customizer which understands {@link org.kuali.rice.krad.data.jpa.PortableSequenceGenerator}
 * annotations and automatically registers custom EclipseLink Sequences.
 *
 * <p>
 * Since SessionCustomizers are stateless instances, and because concrete
 * {@link org.eclipse.persistence.sequencing.Sequence} objects must be registered individually with the EclipseLink
 * session, we lazy generate the Sequence objects using annotation inspection and then register them on each new
 * session using this customizer.
 * </p>
 *
 * @author Kuali Rice Team (rice.collab@kuali.org)
 */
public class KradEclipseLinkCustomizer implements SessionCustomizer {

    private static ConcurrentMap<String, List<Sequence>> sequenceMap = new ConcurrentHashMap<String, List<Sequence>>(8,
            0.9f, 1);

    /* Keyed by the session name determines if the class descriptors have been modified for the current session. */
    private static ConcurrentMap<String, Boolean> modDescMap = new ConcurrentHashMap<String, Boolean>();

    private static ConcurrentMap<String, List<FilterGenerator>> queryCustomizerMap =
            new ConcurrentHashMap<String, List<FilterGenerator>>();

    /**
     * {@inheritDoc}
     */
    @Override
    public void customize(Session session) throws Exception {
        String sessionName = session.getName();

        // double-checked locking on ConcurrentMap
        List<Sequence> sequences = sequenceMap.get(sessionName);
        if (sequences == null) {
            sequences = sequenceMap.putIfAbsent(sessionName, loadSequences(session));
            if (sequences == null) {
                sequences = sequenceMap.get(sessionName);
            }
        }

        loadQueryCustomizers(session);

        DatabaseLogin login = session.getLogin();
        for (Sequence sequence : sequences) {
            login.addSequence(sequence);
        }

        handleDescriptorModifications(session);

    }

    /**
     * Load Query Customizer based on annotations on fields and call customizer to modify descriptor.
     *
     * @param session the EclipseLink session.
     */
    protected void loadQueryCustomizers(Session session) {
        Map<Class, ClassDescriptor> descriptors = session.getDescriptors();
        for (Class<?> entityClass : descriptors.keySet()) {
            for (Field field : entityClass.getDeclaredFields()) {
                String queryCustEntry = entityClass.getName() + "_" + field.getName();
                buildQueryCustomizers(entityClass,field,queryCustEntry);

                List<FilterGenerator> queryCustomizers = queryCustomizerMap.get(queryCustEntry);
                if (queryCustomizers != null && !queryCustomizers.isEmpty()) {
                    Filter.customizeField(queryCustomizers, descriptors.get(entityClass), field.getName());
                }
            }
        }

    }

    /**
     * Build and populate map of QueryCustomizer annotations.
     *
     * @param entityClass the type of the entity.
     * @param field the field to process.
     * @param key the id to store the customizer under.
     */
    protected void buildQueryCustomizers(Class<?> entityClass,Field field, String key){
        FilterGenerators customizers = field.getAnnotation(FilterGenerators.class);
        List<FilterGenerator> filterGenerators = new ArrayList<FilterGenerator>();
        if(customizers != null){
            filterGenerators.addAll(Arrays.asList(customizers.value()));
        } else {
            FilterGenerator customizer = field.getAnnotation(FilterGenerator.class);
            if(customizer != null){
                filterGenerators.add(customizer);
            }
        }
        for(FilterGenerator customizer : filterGenerators){
            List<FilterGenerator> filterCustomizers = queryCustomizerMap.get(key);
            if (filterCustomizers == null) {
                filterCustomizers =
                        new ArrayList<FilterGenerator>();
                filterCustomizers.add(customizer);
                queryCustomizerMap.putIfAbsent(key, filterCustomizers);
            } else {
                filterCustomizers.add(customizer);
                queryCustomizerMap.put(key,filterCustomizers);
            }
        }
    }

    /**
     * Determines if the class descriptors have been modified for the given session name.
     *
     * @param session the current session.
     */
    protected void handleDescriptorModifications(Session session) {
        String sessionName = session.getName();

        // double-checked locking on ConcurrentMap
        Boolean descModified = modDescMap.get(sessionName);
        if (descModified == null) {
            descModified = modDescMap.putIfAbsent(sessionName, Boolean.FALSE);
            if (descModified == null) {
                descModified = modDescMap.get(sessionName);
            }
        }

        if (Boolean.FALSE.equals(descModified)) {
            modDescMap.put(sessionName, Boolean.TRUE);
            handleDisableVersioning(session);
            handleRemoveMapping(session);
        }
    }

    /**
     * Checks class descriptors for {@link @DisableVersioning} annotations at the class level and removes the version
     * database mapping for optimistic locking.
     *
     * @param session the current session.
     */
    protected void handleDisableVersioning(Session session) {
        Map<Class, ClassDescriptor> descriptors = session.getDescriptors();

        if (descriptors == null || descriptors.isEmpty()) {
            return;
        }

        for (ClassDescriptor classDescriptor : descriptors.values()) {
            if (classDescriptor != null && AnnotationUtils.findAnnotation(classDescriptor.getJavaClass(),
                    DisableVersioning.class) != null) {
                OptimisticLockingPolicy olPolicy = classDescriptor.getOptimisticLockingPolicy();
                if (olPolicy != null) {
                    classDescriptor.setOptimisticLockingPolicy(null);
                }
            }
        }
    }

    /**
     * Checks class descriptors for {@link @RemoveMapping} and {@link RemoveMappings} annotations at the class level
     * and removes any specified mappings from the ClassDescriptor.
     *
     * @param session the current session.
     */
    protected void handleRemoveMapping(Session session) {
        Map<Class, ClassDescriptor> descriptors = session.getDescriptors();

        if (descriptors == null || descriptors.isEmpty()) {
            return;
        }

        for (ClassDescriptor classDescriptor : descriptors.values()) {
            List<DatabaseMapping> mappingsToRemove = new ArrayList<DatabaseMapping>();
            List<RemoveMapping> removeMappings = scanForRemoveMappings(classDescriptor);

            for (RemoveMapping removeMapping : removeMappings) {
                if (StringUtils.isBlank(removeMapping.name())) {
                    throw DescriptorException.attributeNameNotSpecified();
                }

                DatabaseMapping databaseMapping = classDescriptor.getMappingForAttributeName(removeMapping.name());

                if (databaseMapping == null) {
                    throw DescriptorException.mappingForAttributeIsMissing(removeMapping.name(), classDescriptor);
                }

                mappingsToRemove.add(databaseMapping);
            }

            for (DatabaseMapping mappingToRemove : mappingsToRemove) {
                classDescriptor.removeMappingForAttributeName(mappingToRemove.getAttributeName());
            }
        }
    }

    /**
     * Gets any {@link RemoveMapping}s out of the given {@link ClassDescriptor}.
     *
     * @param classDescriptor the {@link ClassDescriptor} to scan.
     * @return a list of {@link RemoveMapping}s from the given {@link ClassDescriptor}.
     */
    protected List<RemoveMapping> scanForRemoveMappings(ClassDescriptor classDescriptor) {
        List<RemoveMapping> removeMappings = new ArrayList<RemoveMapping>();
        RemoveMappings removeMappingsAnnotation = AnnotationUtils.findAnnotation(classDescriptor.getJavaClass(),
                RemoveMappings.class);
        if (removeMappingsAnnotation == null) {
            RemoveMapping removeMappingAnnotation = AnnotationUtils.findAnnotation(classDescriptor.getJavaClass(),
                    RemoveMapping.class);
            if (removeMappingAnnotation != null) {
                removeMappings.add(removeMappingAnnotation);
            }
        } else {
            for (RemoveMapping removeMapping : removeMappingsAnnotation.value()) {
                removeMappings.add(removeMapping);
            }
        }
        return removeMappings;
    }

    /**
     * Gets any {@link Sequence} from the session.
     *
     * @param session the current session.
     * @return a list of {@link Sequence}s.
     */
    protected List<Sequence> loadSequences(Session session) {
        Map<Class, ClassDescriptor> descriptors = session.getDescriptors();
        List<PortableSequenceGenerator> sequenceGenerators = new ArrayList<PortableSequenceGenerator>();
        for (Class<?> entityClass : descriptors.keySet()) {
            PortableSequenceGenerator sequenceGenerator = AnnotationUtils.findAnnotation(entityClass,
                    PortableSequenceGenerator.class);
            if (sequenceGenerator != null) {
                sequenceGenerators.add(sequenceGenerator);
            }
            loadFieldSequences(entityClass, sequenceGenerators);
            for (Method method : entityClass.getMethods()) {
                PortableSequenceGenerator methodSequenceGenerator = method.getAnnotation(
                        PortableSequenceGenerator.class);
                if (methodSequenceGenerator != null) {
                    sequenceGenerators.add(methodSequenceGenerator);
                }
            }
        }
        List<Sequence> sequences = new ArrayList<Sequence>();
        for (PortableSequenceGenerator sequenceGenerator : sequenceGenerators) {
            Sequence sequence = new MaxValueIncrementerSequenceWrapper(sequenceGenerator);
            sequences.add(sequence);
        }
        return sequences;
    }

    /**
     * Loads any field-based sequences from the given type.
     *
     * @param entityClass the type of the entity.
     * @param sequenceGenerators the current list of sequence generators.
     */
    protected void loadFieldSequences(Class<?> entityClass, List<PortableSequenceGenerator> sequenceGenerators) {
        for (Field field : entityClass.getDeclaredFields()) {
            PortableSequenceGenerator fieldSequenceGenerator = field.getAnnotation(PortableSequenceGenerator.class);
            if (fieldSequenceGenerator != null) {
                sequenceGenerators.add(fieldSequenceGenerator);
            }
        }
        // next, walk up and check the super class...
        if (entityClass.getSuperclass() != null) {
            loadFieldSequences(entityClass.getSuperclass(), sequenceGenerators);
        }
    }

    /**
     * Translates our {@link PortableSequenceGenerator} into an EclipseLink {@link Sequence}.
     */
    private static final class MaxValueIncrementerSequenceWrapper extends Sequence {

        private static final long serialVersionUID = 2375805962996574386L;

        private final String sequenceName;

        /**
         * Creates a sequence wrapper for our {@link PortableSequenceGenerator}.
         *
         * @param sequenceGenerator the {@link PortableSequenceGenerator} to process.
         */
        MaxValueIncrementerSequenceWrapper(PortableSequenceGenerator sequenceGenerator) {
            super(sequenceGenerator.name(), 0);
            // default sequenceName to the name of the sequence generator if the sequence name was not provided
            if (StringUtils.isBlank(sequenceGenerator.sequenceName())) {
                sequenceName = sequenceGenerator.name();
            } else {
                sequenceName = sequenceGenerator.sequenceName();
            }
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public boolean shouldAcquireValueAfterInsert() {
            return false;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public boolean shouldUseTransaction() {
            return true;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public boolean shouldUsePreallocation() {
            return false;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public Object getGeneratedValue(Accessor accessor, AbstractSession writeSession, String seqName) {
            DataSource dataSource = ((JNDIConnector) writeSession.getLogin().getConnector()).getDataSource();
            DataFieldMaxValueIncrementer incrementer = MaxValueIncrementerFactory.getIncrementer(dataSource,
                    sequenceName);
            return Long.valueOf(incrementer.nextLongValue());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public Vector<?> getGeneratedVector(Accessor accessor, AbstractSession writeSession, String seqName, int size) {
            // we're not in the business of pre-fetching/allocating ids
            throw new UnsupportedOperationException(getClass().getName() + " does pre-generate sequence ids");
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void onConnect() {}

        /**
         * {@inheritDoc}
         */
        @Override
        public void onDisconnect() {}

        /**
         * {@inheritDoc}
         */
        @Override
        public MaxValueIncrementerSequenceWrapper clone() {
            return (MaxValueIncrementerSequenceWrapper) super.clone();
        }

    }

}