package org.webslinger.bsf;

 import java.util.Arrays;

 import java.util.Vector;

 import org.apache.bsf.BSFException;

 public class ApplyKeyDynamic<C> extends ApplyKey<C> {

     private final String[] parameterNames;

     private final Object[] parameters;

     public ApplyKeyDynamic(Object id, String[] parameterNames, Object[] parameters) {

         super(id);

         this.parameterNames = parameterNames;

         this.parameters = parameters;

     }

     public String[] getParameterNames() {

         return parameterNames;

     }

     public Object[] getParameters() {

         return parameters;

     }

     public Object[] getArgs(Compiler compiler) {

         Object[] myParameters = getParameters();

         Object[] args = compiler.newWrapArray(myParameters.length);

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

             Object value = myParameters[i];

             Class type = value != null ? value.getClass() : null;

             args[i] = compiler.wrap(value, type);

         }

         return args;

     }

     public Key<C> freeze() {

         String[] myParameterNames = getParameterNames();

         String[] names = new String[myParameterNames.length];

         System.arraycopy(myParameterNames, 0, names, 0, myParameterNames.length);

         Object[] myParameters = getParameters();

         Class[] types = new Class[myParameters.length];

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

             Object arg = myParameters[i];

             types[i] = arg != null ? arg.getClass() : Void.TYPE;

         }

         return new ApplyKey<C>(getId(), names, types);

     }

     protected int computeHashCode() {

         int tmpHashCode = super.computeHashCode();

         String[] myParameterNames = getParameterNames();

         int length = myParameterNames.length;

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

             tmpHashCode ^= myParameterNames[i].hashCode();

         }

         Object[] myParameters = getParameters();

         length = myParameters.length;

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

             Object arg = myParameters[i];

             if (arg == null) {

                 tmpHashCode ^= Void.TYPE.hashCode();

             } else {

                 tmpHashCode ^= arg.getClass().hashCode();

             }

         }

         return tmpHashCode;

     }

     protected boolean keyEquals(Key key) {

         if (!super.keyEquals(key)) return false;

         String[] myParameterNames = getParameterNames();

         Object[] myParameters = getParameters();

         if (key instanceof ApplyKeyDynamic) {

             ApplyKeyDynamic other = (ApplyKeyDynamic) key;

             String[] otherParameterNames = other.getParameterNames();

             if (!Arrays.equals(myParameterNames, otherParameterNames)) return false;

             Object[] otherArgs = other.getParameters();

             return Arrays.equals(myParameters, otherArgs);

         } else {

             ApplyKey other = (ApplyKey) key;

             String[] otherNames = other.getNames();

             if (!Arrays.equals(myParameterNames, otherNames)) return false;

             Class[] otherTypes = other.getTypes();

             if (myParameters.length != otherTypes.length) return false;

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

                 Object arg = myParameters[i];

                 Class otherType = otherTypes[i];

                 if (arg == null) {

                     if (otherType == Void.TYPE) continue;

                     return false;

                 } else {

                     if (otherType == Void.TYPE) return false;

                     if (!arg.getClass().equals(otherType)) return false;

                 }

             }

         }

         return true;

     }

     public <V> C compile(Compiler<V, C> compiler, Compiler<V, C>.CompilerContext context) throws BSFException {

         throw new IllegalArgumentException("not implemented");

     }

 }