/*
 * Copyright 2001-2008 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.juddi.api.impl;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.jws.WebService;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import static org.apache.juddi.api.impl.AuthenticatedService.logger;
import org.apache.juddi.api.util.QueryStatus;
import org.apache.juddi.api.util.ValueSetValidationQuery;
import org.apache.juddi.config.PersistenceManager;
import org.apache.juddi.model.Tmodel;
import org.apache.juddi.v3.client.UDDIConstants;
import org.apache.juddi.v3.client.UDDIConstantsV2;
import org.apache.juddi.v3.error.ErrorMessage;
import org.apache.juddi.v3.error.FatalErrorException;
import org.apache.juddi.v3.error.ValueNotAllowedException;
import org.apache.juddi.validation.vsv.AbstractSimpleValidator;
import org.apache.juddi.validation.vsv.ValueSetValidator;
import org.uddi.api_v3.BindingTemplate;
import org.uddi.api_v3.BusinessEntity;
import org.uddi.api_v3.BusinessService;
import org.uddi.api_v3.DispositionReport;
import org.uddi.api_v3.KeyedReference;
import org.uddi.api_v3.KeyedReferenceGroup;
import org.uddi.api_v3.PublisherAssertion;
import org.uddi.api_v3.Result;
import org.uddi.api_v3.TModel;
import org.uddi.api_v3.TModelInstanceInfo;
import org.uddi.v3_service.DispositionReportFaultMessage;
import org.uddi.v3_service.UDDIValueSetValidationPortType;
import org.uddi.vs_v3.ValidateValues;

/**
 * Implementation the UDDI v3 spec for Value Set Validation This is basically
 * used to validate Keyed Reference value sets and offers validation via jUDDI's
 * VSV extensibility framework.<Br><BR>
 * To use this, define a tModel containing the following
 * <pre>&lt;categoryBag&gt;
 * &lt;keyedReference keyName=&quot;&quot;
 * keyValue=&quot;uddi:juddi.apache.org:servicebindings-valueset-cp&quot;
 * tModelKey=&quot;uddi:uddi.org:identifier:validatedby&quot;/&gt;
 * &lt;/categoryBag&gt;
 * </pre>Where uddi:juddi.apache.org:servicebindings-valueset-cp is the binding
 * key of the service implementing the VSV API (this service).
 * <Br><BR>
 * From there, you need to create a class that either implements
 * {@link ValueSetValidator} or extends {@link AbstractSimpleValidator}. It must
 * be in the package named org.apache.juddi.validation.vsv and must by named
 * following the convention outlined in {@link #convertKeyToClass(java.lang.String)
 * }
 *
 * @see ValueSetValidator
 * @see AbstractSimpleValidator
 * @author <a href="mailto:alexoree@apache.org">Alex O'Ree</a>
 */
@WebService(serviceName="UDDIValueSetCachingService", endpointInterface = "org.uddi.v3_service.UDDIValueSetValidationPortType"
       , targetNamespace = "urn:uddi-org:api_v3_portType")
public class UDDIValueSetValidationImpl extends AuthenticatedService implements
     UDDIValueSetValidationPortType {

        private UDDIServiceCounter serviceCounter;

        public UDDIValueSetValidationImpl() {
                super();
                serviceCounter = ServiceCounterLifecycleResource.getServiceCounter(this.getClass());
        }

        @Override
        public DispositionReport validateValues(ValidateValues body)
             throws DispositionReportFaultMessage {
                long startTime = System.currentTimeMillis();

                if (body == null) {
                        long procTime = System.currentTimeMillis() - startTime;
                        serviceCounter.update(ValueSetValidationQuery.VALIDATE_VALUES,
                             QueryStatus.FAILED, procTime);

                        throw new ValueNotAllowedException(new ErrorMessage("errors.valuesetvalidation.noinput"));
                }
                /*
                 * The UDDI node that is calling validate_values MUST pass one 
                 * or more businessEntity elements, one or more businessService 
                 * elements, one or more bindingTemplate elements, one or more 
                 * tModel elements, or one or more publisherAssertion elements 
                 * as the sole argument to this Web service. 
                 * */


                /* performs validation on all of the keyedReferences or keyedReferenceGroups */

                /*when the entity being saved is a businessEntity, contained 
                 * businessService and bindingTemplate entities may themselves 
                 * reference values from the authorized value sets as well. */
                //go through all published items
                //pull out all keys
                //look up keys in database for a validation class
                //dedup results
                //run validation classes
                List<String> classNames = new ArrayList<String>();
                classNames.addAll(validateValuesBindingTemplate(body.getBindingTemplate()));
                classNames.addAll(validateValuesBusinessEntity(body.getBusinessEntity()));
                classNames.addAll(validateValuesBusinessService(body.getBusinessService()));
                classNames.addAll(validateValuesPublisherAssertion(body.getPublisherAssertion()));
                classNames.addAll(validateValuesTModel(body.getTModel()));
                Set<String> set = new HashSet<String>(classNames);
                Iterator<String> iterator = set.iterator();
                Set<String> validators = new HashSet<String>();
                EntityManager em = PersistenceManager.getEntityManager();
                EntityTransaction tx = em.getTransaction();
                //for each key to process
                try {
                        while (iterator.hasNext()) {

                                String key = iterator.next();
                                //find out if it needs to be validated
                                Tmodel find = em.find(org.apache.juddi.model.Tmodel.class, key);
                                if (find != null) {
                                        //if it is, added it to the list
                                        if (containsValidatedKey(find, UDDIConstants.IS_VALIDATED_BY)) {
                                                validators.add(key);
                                        }
                                        if (containsValidatedKey(find, UDDIConstantsV2.IS_VALIDATED_BY)) {
                                                validators.add(key);
                                        }
                                }
                        }

                } catch (Exception drfm) {
                        logger.warn("Unable to process vsv validation", drfm);
                        throw new FatalErrorException(new ErrorMessage("errors.valuesetvalidation.fatal", drfm.getMessage()));
                } finally {
                        if (tx.isActive()) {
                                tx.rollback();
                        }
                        em.close();
                }
                Iterator<String> iterator1 = validators.iterator();
                while (iterator1.hasNext()) {
                        String tmodelkey = iterator1.next();
                        String clazz = convertKeyToClass(tmodelkey);
                        ValueSetValidator vsv;
                        if (clazz == null) {
                                logger.info("No validator found for " + tmodelkey);
                        } else {
                                try {
                                        vsv = (ValueSetValidator) Class.forName(clazz).newInstance();
                                        logger.info("translated " + tmodelkey + " to class " + clazz);
                                        vsv.validateValuesBindingTemplate(body.getBindingTemplate(), "");
                                        vsv.validateValuesBusinessEntity(body.getBusinessEntity());
                                        vsv.validateValuesBusinessService(body.getBusinessService(), "");
                                        vsv.validateValuesPublisherAssertion(body.getPublisherAssertion());
                                        vsv.validateValuesTModel(body.getTModel());
                                } catch (ClassNotFoundException ex) {
                                        logger.warn("Unable to process vsv validation for " + tmodelkey, ex);
                                        throw new FatalErrorException(new ErrorMessage("errors.valuesetvalidation.fatal", "key=" + tmodelkey + " class=" + clazz + " " + ex.getMessage()));
                                } catch (InstantiationException ex) {
                                        logger.warn("Unable to process vsv validation for " + tmodelkey, ex);
                                        throw new FatalErrorException(new ErrorMessage("errors.valuesetvalidation.fatal", "key=" + tmodelkey + " class=" + clazz + " " + ex.getMessage()));
                                } catch (IllegalAccessException ex) {
                                        logger.warn("Unable to process vsv validation for " + tmodelkey, ex);
                                        throw new FatalErrorException(new ErrorMessage("errors.valuesetvalidation.fatal", "key=" + tmodelkey + " class=" + clazz + " " + ex.getMessage()));
                                }
                        }
                }

                DispositionReport r = new DispositionReport();
                r.getResult().add(new Result());
                long procTime = System.currentTimeMillis() - startTime;
                serviceCounter.update(ValueSetValidationQuery.VALIDATE_VALUES,
                     QueryStatus.SUCCESS, procTime);

                return r;
        }

        private List<String> validateValuesBindingTemplate(List<BindingTemplate> items) {
                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }
                for (int i = 0; i < items.size(); i++) {
                        if (items.get(i).getCategoryBag() != null) {
                                ret.addAll(validateValuesKeyRef(items.get(i).getCategoryBag().getKeyedReference()));
                                ret.addAll(validateValuesKeyRefGrp(items.get(i).getCategoryBag().getKeyedReferenceGroup()));
                        }
                        if (items.get(i).getTModelInstanceDetails() != null) {

                                //validateTmodelInstanceDetails(items.get(i).getTModelInstanceDetails().getTModelInstanceInfo(), xpath + "bindingTemplate(" + i + ").tModelInstanceDetails.");
                        }
                }
                return ret;
        }

        private List<String> validateValuesBusinessEntity(List<BusinessEntity> items) {
                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }
                for (int i = 0; i < items.size(); i++) {
                        if (items.get(i).getCategoryBag() != null) {
                                ret.addAll(validateValuesKeyRef(items.get(i).getCategoryBag().getKeyedReference()));
                                ret.addAll(validateValuesKeyRefGrp(items.get(i).getCategoryBag().getKeyedReferenceGroup()));
                        }
                        if (items.get(i).getIdentifierBag() != null) {
                                ret.addAll(validateValuesKeyRef(items.get(i).getIdentifierBag().getKeyedReference()));
                        }
                        if (items.get(i).getBusinessServices() != null) {
                                ret.addAll(validateValuesBusinessService(items.get(i).getBusinessServices().getBusinessService()));
                        }
                }
                return ret;
        }

        private List<String> validateValuesBusinessService(List<BusinessService> items) {
                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }
                for (int i = 0; i < items.size(); i++) {
                        if (items.get(i).getCategoryBag() != null) {
                                ret.addAll(validateValuesKeyRef(items.get(i).getCategoryBag().getKeyedReference()));
                                ret.addAll(validateValuesKeyRefGrp(items.get(i).getCategoryBag().getKeyedReferenceGroup()));
                        }
                        if (items.get(i).getBindingTemplates() != null) {
                                ret.addAll(validateValuesBindingTemplate(items.get(i).getBindingTemplates().getBindingTemplate()));
                        }
                }
                return ret;
        }

        private List<String> validateValuesPublisherAssertion(List<PublisherAssertion> items) {

                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }
                for (int i = 0; i < items.size(); i++) {
                        if (items.get(i).getKeyedReference() != null) {
                                List<KeyedReference> temp = new ArrayList<KeyedReference>();
                                temp.add(items.get(i).getKeyedReference());
                                ret.addAll(validateValuesKeyRef(temp));
                        }
                }
                return ret;
        }

        private List<String> validateValuesTModel(List<TModel> items) {
                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }
                for (int i = 0; i < items.size(); i++) {
                        if (items.get(i).getCategoryBag() != null) {
                                ret.addAll(validateValuesKeyRef(items.get(i).getCategoryBag().getKeyedReference()));
                                ret.addAll(validateValuesKeyRefGrp(items.get(i).getCategoryBag().getKeyedReferenceGroup()));
                        }
                        if (items.get(i).getIdentifierBag() != null) {
                                ret.addAll(validateValuesKeyRef(items.get(i).getIdentifierBag().getKeyedReference()));
                        }
                }
                return ret;
        }

        private List<String> validateValuesKeyRef(List<KeyedReference> items) {
                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }

                for (int i = 0; i < items.size(); i++) {
                        ret.add(items.get(i).getTModelKey());
                }

                return ret;
        }

        private List<String> validateValuesKeyRefGrp(List<KeyedReferenceGroup> items) {
                List<String> ret = new ArrayList<String>();
                if (items == null) {
                        return ret;
                }
                for (int i = 0; i < items.size(); i++) {
                        ret.addAll(validateValuesKeyRef(items.get(i).getKeyedReference()));
                }
                return ret;
        }

        

        public static String convertKeyToClass(String tmodelkey) {

                if (tmodelkey == null) {
                        return null;
                }
                if (tmodelkey.length() < 2) {
                        return null;
                }

                String key = new String(new char[]{tmodelkey.charAt(0)}).toUpperCase() + tmodelkey.substring(1).toLowerCase();
                key = key.replaceAll("[^a-zA-Z0-9]", "");

                String clazz = "org.apache.juddi.validation.vsv." + key;

                return clazz;

        }

        public static List<String> getValidValues(String modelKey) {
                try {
                        ValueSetValidator vsv = (ValueSetValidator) Class.forName(convertKeyToClass(modelKey)).newInstance();
                        return vsv.getValidValues();
                } catch (ClassNotFoundException ex) {
                } catch (InstantiationException ex) {
                } catch (IllegalAccessException ex) {
                }
                return null;
        }

        private boolean containsValidatedKey(Tmodel find, String key) {
                if (find.getCategoryBag() != null) {
                        if (find.getCategoryBag().getKeyedReferences() != null) {
                                for (int i = 0; i < find.getCategoryBag().getKeyedReferences().size(); i++) {
                                        if (key.equalsIgnoreCase(find.getCategoryBag().getKeyedReferences().get(i).getTmodelKeyRef())) {
                                                return true;
                                        }
                                }
                        }
                        if (find.getCategoryBag().getKeyedReferenceGroups() != null) {
                                for (int i = 0; i < find.getCategoryBag().getKeyedReferenceGroups().size(); i++) {
                                        for (int k = 0; k < find.getCategoryBag().getKeyedReferenceGroups().get(i).getKeyedReferences().size(); k++) {
                                                if (key.equalsIgnoreCase(find.getCategoryBag().getKeyedReferenceGroups().get(i).getKeyedReferences().get(k).getTmodelKeyRef())) {
                                                        return true;
                                                }
                                        }
                                }
                        }
                }
                if (find.getTmodelIdentifiers() != null) {

                        for (int i = 0; i < find.getTmodelIdentifiers().size(); i++) {
                                if (key.equalsIgnoreCase(find.getTmodelIdentifiers().get(i).getTmodelKeyRef())) {
                                        return true;
                                }
                        }
                }

                return false;
        }
}