/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.cxf.jaxrs.ext.search.visitor;

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.cxf.jaxrs.ext.search.PrimitiveStatement;
import org.apache.cxf.jaxrs.ext.search.SearchConditionVisitor;
import org.apache.cxf.jaxrs.ext.search.collections.CollectionCheckInfo;
import org.apache.cxf.jaxrs.ext.search.collections.CollectionCheckStatement;
import org.apache.cxf.jaxrs.utils.InjectionUtils;


public abstract class AbstractSearchConditionVisitor <T, E> implements SearchConditionVisitor<T, E> {
    
    private Map<String, String> fieldMap;
    private Map<String, Class<?>> primitiveFieldTypeMap;
    private PropertyValidator<Object> validator;
    private boolean wildcardStringMatch;
    
    protected AbstractSearchConditionVisitor(Map<String, String> fieldMap) {
        this.fieldMap = fieldMap;
    }
    
    protected String getRealPropertyName(String name) {
        if (fieldMap != null && fieldMap.containsKey(name)) {
            return fieldMap.get(name);
        }
        return name;
    }

    protected Class<?> getPrimitiveFieldClass(String name, Class<?> valueCls) {
        return getPrimitiveFieldClass(name, valueCls, null).getCls(); 
    }    
    
    protected ClassValue getPrimitiveFieldClass(String name, Class<?> valueCls, Object value) {
        return getPrimitiveFieldClass(null, name, valueCls, valueCls, value);
    }
    
    protected ClassValue getPrimitiveFieldClass(PrimitiveStatement ps, String name, Class<?> valueCls, 
                                                Type type, Object value) {
        return doGetPrimitiveFieldClass(ps, name, valueCls, type, value, new HashSet<String>());
    }
    
    @SuppressWarnings("rawtypes")
    private ClassValue doGetPrimitiveFieldClass(PrimitiveStatement ps,
                                                String name, Class<?> valueCls, Type type, Object value, 
                                                Set<String> set) {
        boolean isCollection = InjectionUtils.isSupportedCollectionOrArray(valueCls);
        Class<?> actualCls = isCollection ? InjectionUtils.getActualType(type) : valueCls;
        CollectionCheckInfo collInfo = null;
        int index = name.indexOf(".");
        if (index != -1) {
            String[] names = name.split("\\.");
            name = name.substring(index + 1);
            if (value != null && !InjectionUtils.isPrimitive(actualCls)) {
                try {
                    String nextPart = names[1];
                    if (nextPart.length() == 1) {
                        nextPart = nextPart.toUpperCase();
                    } else {
                        nextPart = Character.toUpperCase(nextPart.charAt(0)) + nextPart.substring(1);
                    }
                    
                    Method m = actualCls.getMethod("get" + nextPart, new Class[]{});
                    if (isCollection) {
                        value = ((Collection)value).iterator().next();
                        set.add(names[0]);
                    }
                    value = m.invoke(value, new Object[]{});
                    valueCls = value.getClass();
                    type = m.getGenericReturnType();
                } catch (Throwable ex) {
                    throw new RuntimeException();
                }
                return doGetPrimitiveFieldClass(ps, name, valueCls, type, value, set);
            }
        } else if (isCollection) {
            set.add(name);
            Collection coll = (Collection)value;
            value = coll.isEmpty() ? null : coll.iterator().next();
            valueCls = actualCls;
            if (ps instanceof CollectionCheckStatement) { 
                collInfo = ((CollectionCheckStatement)ps).getCollectionCheckInfo();
            }
        }
        
        Class<?> cls = null;
        if (primitiveFieldTypeMap != null) {
            cls = primitiveFieldTypeMap.get(name);
        }
        if (cls == null) {  
            cls = valueCls;
        }
        return new ClassValue(cls, value, collInfo, set);
    }

    public void setPrimitiveFieldTypeMap(Map<String, Class<?>> primitiveFieldTypeMap) {
        this.primitiveFieldTypeMap = primitiveFieldTypeMap;
    }
    
    public SearchConditionVisitor<T, E> visitor() {
        return this;
    }
    
    protected class ClassValue {
        private Class<?> cls;
        private Object value;
        private CollectionCheckInfo collInfo;
        
        private Set<String> collectionProps;
        public ClassValue(Class<?> cls, 
                          Object value,
                          CollectionCheckInfo collInfo,
                          Set<String> collectionProps) {
            this.cls = cls;
            this.value = value;
            this.collInfo = collInfo;
            this.collectionProps = collectionProps;       
        }
        public Class<?> getCls() {
            return cls;
        }
        public void setCls(Class<?> cls) {
            this.cls = cls;
        }
        public Object getValue() {
            return value;
        }
        public void setValue(Object value) {
            this.value = value;
        }
        
        public CollectionCheckInfo getCollectionCheckInfo() {
            return collInfo;
        }
        
        public boolean isCollection(String name) {
            return collectionProps != null && collectionProps.contains(name);
        }
    }
    
    protected void validatePropertyValue(String name, Object value) {
        if (validator != null) {
            validator.validate(name, value);
        }
    }
    
    public void setValidator(PropertyValidator<Object> validator) {
        this.validator = validator;
    }

    public boolean isWildcardStringMatch() {
        return wildcardStringMatch;
    }

    public void setWildcardStringMatch(boolean wildcardStringMatch) {
        this.wildcardStringMatch = wildcardStringMatch;
    }
}
