package com.hammurapi.extract.java;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.codehaus.commons.compiler.CompileException;
import org.codehaus.janino.ExpressionEvaluator;

import com.hammurapi.common.Identifiable;
import com.hammurapi.extract.ComparisonResult;
import com.hammurapi.extract.Extractor;
import com.hammurapi.extract.ExtractorBase;
import com.hammurapi.extract.ExtractorException;
import com.hammurapi.extract.Mappable;

public class JavaExtractor<T, V, C> extends ExtractorBase<T, V, C> implements Extractor<T, V, C> , Mappable<T,V,C>, Identifiable<List<Object>>  {

        private Params<T, C> params;
        private Class<V> valueType;
        private ClassLoader classLoader;

        public JavaExtractor(double initialCost, TimeUnit costUnit, Params<T, C> params, Class<V> valueType, ClassLoader classLoader) {
                super(initialCost, costUnit);
                this.params = params;
                this.valueType = valueType;
                this.classLoader = classLoader;
        }
        
        private ThreadLocal<ExpressionEvaluator> eetl = new ThreadLocal<ExpressionEvaluator>() {
                
                protected ExpressionEvaluator initialValue() {                  
                        try {
                                // TODO - Pass classLoader?
                                return new ExpressionEvaluator(params.expr.toString(), valueType, params.names, params.types);
                        } catch (CompileException e) {
                                throw new ExtractorException("Compile exception in code '"+params.expr+"': "+e, e);
                        }
                };
        };

        @SuppressWarnings("unchecked")
        @Override
        protected V extractInternal(C context, Map<C, Map<Extractor<T, ? super V, C>, ? super V>> cache, T... obj) {
                Object[] args = params.translate(obj, context);
                try {
                        return (V) eetl.get().evaluate(args);
                } catch (Exception e) {
                        throw new ExtractorException("Invocation exception in code '"+params.expr+"': "+e, e);
                }
        }

        @Override
        public boolean isContextDependent() {
                return params.isContextDependent();
        }

        @Override
        public Set<Integer> parameterIndices() {
                return params.indices;
        }
        
        @Override
        public String toString() {
                return getClass().getName()+"(code: '"+params.expr+"', parameter indices "+parameterIndices()+", cost: "+getCost()+")";
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result
                                + ((classLoader == null) ? 0 : classLoader.hashCode());
                result = prime * result + ((params == null) ? 0 : params.hashCode());
                result = prime * result
                                + ((valueType == null) ? 0 : valueType.hashCode());
                return result;
        }
        
        @Override
        public ComparisonResult compareTo(Extractor<T, V, C> obj) {
                if (this == obj) {
                        return ComparisonResult.EQUAL_NM;
                }
                if (obj == null) {
                        return ComparisonResult.NOT_EQUAL_NM;
                }
                        
                if (getClass() != obj.getClass()) {
                        return super.compareTo(obj); // For parenthesis, facades and other stuff.
                }

                JavaExtractor other = (JavaExtractor) obj;
                if (classLoader == null) {
                        if (other.classLoader != null) {
                                return ComparisonResult.NOT_EQUAL_NM;
                        }
                } else if (!classLoader.equals(other.classLoader)) {
                        return ComparisonResult.NOT_EQUAL_NM;
                }

                if (params == null) {
                        if (other.params != null) {
                                return ComparisonResult.NOT_EQUAL_NM;
                        }
                } else if (!params.equals(other.params)) {
                        return ComparisonResult.NOT_EQUAL_NM;
                }
                if (valueType == null) {
                        if (other.valueType != null){
                                return ComparisonResult.NOT_EQUAL_NM;
                        }
                } else if (!valueType.equals(other.valueType)) {
                        return ComparisonResult.NOT_EQUAL_NM;
                }
                return ComparisonResult.EQUAL_NM; 
        }

        @SuppressWarnings("unchecked")
        @Override
        public Extractor<T, V, C> map(int[] map) {
                if (ComparisonResult.isOneToOneMapping(map)) {
                        return this;
                }
                
                Params<T,C> newParams = params.map(map);
                if (newParams==null) {
                        return null;
                }
                
                if (this instanceof JavaPredicate) {
                        return (Extractor<T, V, C>) new JavaPredicate<T, C>(initialCost, costUnit, newParams, classLoader);                 
                }
                
                return new JavaExtractor<T, V, C>(initialCost, costUnit, newParams, valueType, classLoader);
        }
        
        public List<Object> getIdentity() {
                return params.getIdentity();
        }
        
        public interface Parameter {
                int getIndex();
                Class<?> getType();
                String getName();
        }

        public Iterable<Parameter> getParameters() {
                Collection<Parameter> ret = new ArrayList<Parameter>();
                final Integer[] ia = params.indices.toArray(new Integer[params.indices.size()]);
                for (int i=0; i<params.names.length; ++i) {
                        class ParameterImpl implements Parameter {
                                
                                private int idx;

                                public ParameterImpl(int idx) {
                                        this.idx = idx;
                                }

                                @Override
                                public int getIndex() {
                                        return ia[idx];
                                }

                                @Override
                                public Class<?> getType() {
                                        return params.types[idx];
                                }

                                @Override
                                public String getName() {
                                        return params.names[idx];
                                }

                                @Override
                                public String toString() {
                                        return "Parameter[idx=" + idx + ", type="
                                                        + getType() + ", name=" + getName() + "]";
                                }               
                                
                                
                        }
                        
                        ret.add(new ParameterImpl(i));
                        
                }
                
                return Collections.unmodifiableCollection(ret);
        }

        public String getExpression() {
                return params.expr.toString();
        }
}