/**
 * 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.hbase;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Stack;

import org.apache.cxf.jaxrs.ext.search.ConditionType;
import org.apache.cxf.jaxrs.ext.search.PrimitiveStatement;
import org.apache.cxf.jaxrs.ext.search.SearchCondition;
import org.apache.cxf.jaxrs.ext.search.visitor.AbstractSearchConditionVisitor;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.ByteArrayComparable;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.RegexStringComparator;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;

public class HBaseQueryVisitor<T> extends AbstractSearchConditionVisitor<T, Filter> {

    private Stack<List<Filter>> queryStack = new Stack<List<Filter>>();
    private String family;
    private Map<String, String> familyMap;
    public HBaseQueryVisitor(String family) {
        this(family, Collections.<String, String>emptyMap());
    }
    public HBaseQueryVisitor(String family, Map<String, String> fieldsMap) {
        super(fieldsMap);
        this.family = family;
        queryStack.push(new ArrayList<Filter>());
    }
    public HBaseQueryVisitor(Map<String, String> familyMap) {
        this(familyMap, Collections.<String, String>emptyMap());
    }
    public HBaseQueryVisitor(Map<String, String> familyMap,
                             Map<String, String> fieldsMap) {
        super(fieldsMap);
        this.familyMap = familyMap;
        queryStack.push(new ArrayList<Filter>());
    }
    
    public void visit(SearchCondition<T> sc) {
        PrimitiveStatement statement = sc.getStatement();
        if (statement != null) {
            if (statement.getProperty() != null) {
                queryStack.peek().add(buildSimpleQuery(sc.getConditionType(), 
                                         statement.getProperty(), 
                                         statement.getValue()));
            }
        } else {
            queryStack.push(new ArrayList<Filter>());
            for (SearchCondition<T> condition : sc.getSearchConditions()) {
                condition.accept(this);
            }
            boolean orCondition = sc.getConditionType() == ConditionType.OR;
            List<Filter> queries = queryStack.pop();
            queryStack.peek().add(createCompositeQuery(queries, orCondition));
        }    
    }

    public Filter getQuery() {
        List<Filter> queries = queryStack.peek();
        return queries.isEmpty() ? null : queries.get(0);
    }
    
    private Filter buildSimpleQuery(ConditionType ct, String name, Object value) {
        name = super.getRealPropertyName(name);
        validatePropertyValue(name, value);
        Class<?> clazz = getPrimitiveFieldClass(name, value.getClass());
        CompareOp compareOp = null;
        boolean regexCompRequired = false;
        switch (ct) {
        case EQUALS:
            compareOp = CompareOp.EQUAL;
            regexCompRequired = String.class == clazz && value.toString().endsWith("*");
            break;
        case NOT_EQUALS:
            compareOp = CompareOp.NOT_EQUAL;
            regexCompRequired = String.class == clazz && value.toString().endsWith("*");
            break;
        case GREATER_THAN:
            compareOp = CompareOp.GREATER;
            break;
        case GREATER_OR_EQUALS:
            compareOp = CompareOp.GREATER_OR_EQUAL;
            break;
        case LESS_THAN:
            compareOp = CompareOp.LESS;
            break;
        case LESS_OR_EQUALS:
            compareOp = CompareOp.LESS_OR_EQUAL;
            break;
        default: 
            break;
        }
        String qualifier = name;
        String theFamily = family != null ? family : familyMap.get(qualifier);
        ByteArrayComparable byteArrayComparable = regexCompRequired 
            ? new RegexStringComparator(value.toString().replace("*", "."))
            : new BinaryComparator(getBytes(value.toString()));
        
        Filter query = new SingleColumnValueFilter(getBytes(theFamily),
                                                   getBytes(qualifier),
                                                   compareOp,
                                                   byteArrayComparable);
        return query;
    }
    
    private Filter createCompositeQuery(List<Filter> queries, boolean orCondition) {
        
        FilterList.Operator oper = orCondition ? FilterList.Operator.MUST_PASS_ONE
            : FilterList.Operator.MUST_PASS_ALL;
        FilterList list = new FilterList(oper);
        for (Filter query : queries) {
            list.addFilter(query);
        }
        return list;
    }
    
    private byte[] getBytes(String value) {
        try {
            return value.getBytes("UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }
}
