package com.facebook.presto.scuba.optimization.translator;

import com.facebook.presto.scuba.optimization.FilterPushdownScubaSql;
import com.facebook.presto.scuba.optimization.functions.BigintOperators;
import com.facebook.presto.scuba.optimization.functions.BooleanOperators;
import com.facebook.presto.scuba.optimization.functions.DoubleOperators;
import com.facebook.presto.scuba.optimization.functions.MathFunctions;
import com.facebook.presto.scuba.optimization.functions.NotFunction;
import com.facebook.presto.scuba.optimization.functions.RealOperators;
import com.facebook.presto.scuba.optimization.functions.StringFunctions;
import com.facebook.presto.scuba.optimization.functions.VarcharOperators;
import com.facebook.presto.spi.function.FunctionMetadata;
import com.google.common.collect.ImmutableMap;

import java.lang.invoke.MethodHandle;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import static com.facebook.presto.scuba.optimization.FilterPushdownScubaSql.PushdownState.FULLY_PUSHABLE;
import static com.facebook.presto.scuba.optimization.FilterPushdownScubaSql.notPushable;
import static com.facebook.presto.scuba.optimization.ScubaScalarFromAnnotationsParser.parseFunctionDefinitions;
import static com.facebook.presto.scuba.optimization.ScubaScalarFromAnnotationsParser.removeTypeParameters;
import static java.lang.String.format;

public class FunctionTranslator
{
    private final Map<FunctionMetadata, MethodHandle> translators;

    public FunctionTranslator()
    {
        this.translators = registerFunctions();
    }

    public static FilterPushdownScubaSql binaryOperatorTranslator(FilterPushdownScubaSql left, FilterPushdownScubaSql right, String operator)
    {
        if (!left.isFullyPushable() || !right.isFullyPushable()) {
            return notPushable();
        }

        return new FilterPushdownScubaSql(FULLY_PUSHABLE, Optional.of(format("(%s) %s (%s)", left.getScubaSQL(), operator, right.getScubaSQL())));
    }

    public static FilterPushdownScubaSql functionTranslator(String function, FilterPushdownScubaSql... arguments)
    {
        if (!Arrays.stream(arguments).allMatch(FilterPushdownScubaSql::isFullyPushable)) {
            return notPushable();
        }

        String translatedFunction = function + "(" + Arrays.stream(arguments).map(FilterPushdownScubaSql::getScubaSQL).collect(Collectors.joining(", ")) + ")";

        return new FilterPushdownScubaSql(FULLY_PUSHABLE, Optional.of(translatedFunction));
    }

    public FilterPushdownScubaSql translate(FunctionMetadata functionSignature, List<FilterPushdownScubaSql> arguments)
    {
        MethodHandle methodHandle = translators.get(removeTypeParameters(functionSignature));

        if (methodHandle == null) {
            return notPushable();
        }

        try {
            return (FilterPushdownScubaSql) methodHandle.invokeWithArguments(arguments);
        }
        catch (RuntimeException e) {
            throw e;
        }
        catch (Throwable t) {
            if (t instanceof InterruptedException) {
                Thread.currentThread().interrupt();
            }
            throw new RuntimeException(t);
        }
    }

    private Map<FunctionMetadata, MethodHandle> registerFunctions()
    {
        ImmutableMap.Builder<FunctionMetadata, MethodHandle> functions = ImmutableMap.builder();
        functions.putAll(parseFunctionDefinitions(BooleanOperators.class))
                .putAll(parseFunctionDefinitions(BigintOperators.class))
                .putAll(parseFunctionDefinitions(DoubleOperators.class))
                .putAll(parseFunctionDefinitions(VarcharOperators.class))
                .putAll(parseFunctionDefinitions(RealOperators.class))
                .putAll(parseFunctionDefinitions(NotFunction.class))
                .putAll(parseFunctionDefinitions(MathFunctions.class))
                .putAll(parseFunctionDefinitions(StringFunctions.class));

        return functions.build();
    }
}