package org.apache.commons.contract;

 import java.util.Map;

 import org.apache.commons.contract.constraints.Constraints;

 import org.apache.commons.contract.constraints.ValidationException;

 import org.apache.commons.contract.descriptor.ParameterDescriptor;

 import org.apache.commons.contract.descriptor.RequiredEnvironmentDescriptor;

 import org.apache.commons.contract.descriptor.ResultDescriptor;

 import org.apache.commons.contract.descriptor.ResultEntryDescriptor;

 import org.apache.commons.i18n.XMLMessageProvider;

 import org.apache.commons.i18n.bundles.ErrorBundle;

 public class Executor {

     static {

         // FIXME - install() method has been removed

         //XMLMessageProvider.install("contract/exceptions", Thread.currentThread().getContextClassLoader().getResourceAsStream("exceptions.xml"));

         //XMLMessageProvider.install("contract/constraints", Thread.currentThread().getContextClassLoader().getResourceAsStream("constraints.xml"));

     }

     public static void init() {};

     public static Result process(Processor processor, Map parameters, Context context) throws Exception {

             prepareValues(processor.getParameterDescriptors(), parameters, context);

         if ( processor instanceof EnvironmentConsumer ) {

             checkRequirements((EnvironmentConsumer)processor, context);

         }

             Result result = processor.process(parameters, context);

         validateResult(processor.getResultDescriptors(), result, context);

         return result;

     }

     public static void prepareValues(ParameterDescriptor[] parameterDescriptors, Map parameters, Context context) throws ContractViolationException {

             for ( int i = 0; i < parameterDescriptors.length; i++ ) {

                     String parameterName = parameterDescriptors[i].getName();

                     Object parameterValue = parameters.get(parameterName);

                     Object preparedValue = prepareValue(parameterDescriptors[i], parameterValue, context);

                     parameters.put(parameterName, preparedValue);

             }

     }

     public static Object prepareValue(ParameterDescriptor parameterDescriptor, Object value, Context context) throws ContractViolationException {

             Object preparedValue;

             if ( value == null ) {

             if ( parameterDescriptor.isRequired() ) {

                 throw new ContractViolationException(new ErrorBundle("requiredParameterMissing", new String[] { parameterDescriptor.getName() }));

             } else {

                 preparedValue = parameterDescriptor.getDefaultValue();

             }

             } else {

             try {

                 preparedValue = parameterDescriptor.getConstraints().cast(value, context);

                 parameterDescriptor.getConstraints().validate(preparedValue, context);

             } catch ( ContractViolationException exception ) {

                 throw new ContractViolationException(new ErrorBundle("invalidParameter", new Object[] { parameterDescriptor.getName() }), exception);

             }

             }

             return preparedValue;

     }

     public static void checkRequirements(EnvironmentConsumer processor, Context context) throws ContractViolationException {

         RequiredEnvironmentDescriptor[] requirementDescriptor = processor.getRequiredEnvironmentDescriptors();

         for ( int i = 0; i < requirementDescriptor.length; i++ ) {

             Store store = context.getStore(requirementDescriptor[i].getStore());

             try {

                 Object value = store.get(requirementDescriptor[i].getName(), context);

                 if ( value == null ) {

                     if ( requirementDescriptor[i].isRequired() ) {

                         throw new ValidationException(new ErrorBundle("requiredContextMissing", new Object[] { requirementDescriptor[i].getName(), requirementDescriptor[i].getStore()}));

                     } else {

                         value = requirementDescriptor[i].getDefaultValue();

                         store.put(requirementDescriptor[i].getName(), value, context);

                     }

                 }

                 Object castedValue = requirementDescriptor[i].getConstraints().cast(value, context);

                 requirementDescriptor[i].getConstraints().validate(castedValue, context);

                 if ( castedValue != value ) {

                     store.put(requirementDescriptor[i].getName(), castedValue, context);

                 }

             } catch ( StoreException exception ) {

                 throw new ContractViolationException(new ErrorBundle("storeUnaccessable", new Object[] { requirementDescriptor[i].getName(), requirementDescriptor[i].getStore()}));

             }

         }

     }

     public static void validateResult(ResultDescriptor[] resultDescriptors, Result result, Context context) throws ContractViolationException {

         ResultEntryDescriptor []entryDescriptors = getResultDescriptorByState(resultDescriptors, result.getState()).getResultEntryDescriptors();

         Map resultEntries = result.getResultEntries();

         String name = null;

         Object value = null;

         try {

             for ( int i = 0; i < entryDescriptors.length; i++ ) {

                 ResultEntryDescriptor entryDescriptor = entryDescriptors[i];

                 name = entryDescriptor.getName();

                 value = resultEntries.get(name);

                 if ( value == null ) throw new ContractViolationException(new ErrorBundle("missingResultEntry", new String[] { name }));

                 Constraints constraints = entryDescriptor.getConstraints();

                 if ( constraints == null ) throw new ContractViolationException(new ErrorBundle("undefinedResultEntryConstraints", new String[] { name }));

                 value = constraints.cast(value, context);

                 entryDescriptor.getConstraints().validate(value, context);

                 resultEntries.put(name, value);

             } 

         } catch ( ValidationException exception ) {

             throw new ContractViolationException(new ErrorBundle("invalidResultEntry", new Object[] { name, value }), exception);

         }

     }

     public static ResultDescriptor getResultDescriptorByState(ResultDescriptor[] resultDescriptors, String state) throws ContractViolationException {

         for ( int i = 0; i < resultDescriptors.length; i++ ) {

             if ( resultDescriptors[i].getStateDescriptor().getState().equals(state)) {

                 return resultDescriptors[i];

             }

         }

         throw new ContractViolationException(new ErrorBundle("stateNotDefined", new Object[] { state }));

     }

 }