package expression.parser;

import expression.ToMiniString;
import expression.common.ExpressionKind;
import expression.common.Reason;
import java.math.BigInteger;
import java.util.function.*;
import java.util.stream.LongStream;

/**
 * @author Georgiy Korneev (kgeorgiy@kgeorgiy.info)
 */
public final class Operations {

    // === Base

    public static final Operation NEGATE = unary("-", 1, a -> -a);

    @SuppressWarnings("Convert2MethodRef")
    public static final Operation ADD = binary("+", 1600, (a, b) -> a + b);

    public static final Operation SUBTRACT = binary("-", 1602, (a, b) -> a - b);
    public static final Operation MULTIPLY = binary("*", 2001, (a, b) -> a * b);
    public static final Operation DIVIDE = binary("/", 2002, (a, b) ->
        b == 0 ? Reason.DBZ.error() : a / b
    );

    // === MinMax
    public static final Operation MIN = binary("min", 401, Math::min);
    public static final Operation MAX = binary("max", 401, Math::max);

    // === Reverse

    private static Operation digits(
        final String name,
        final boolean mask,
        final int r,
        final LongBinaryOperator q
    ) {
        return unary(name, 1, v ->
            LongStream.iterate(
                mask ? v & 0xffff_ffffL : v,
                n -> n != 0,
                n -> n / r
            )
                .map(n -> n % r)
                .reduce(0, q)
        );
    }

    public static final Operation REVERSE = digits(
        "reverse",
        false,
        10,
        (a, b) -> a * 10 + b
    );

    // === Digits
    public static final Operation DIGITS = digits(
        "digits",
        false,
        10,
        Long::sum
    );

    // === Floor and Ceiling

    private static long floor(final long a) {
        return (
            ((a >= 0 ? a : a - FLOOR_CEILING_STEP + 1) / FLOOR_CEILING_STEP) *
            FLOOR_CEILING_STEP
        );
    }

    private static long ceiling(final long a) {
        return (
            ((a >= 0 ? a + FLOOR_CEILING_STEP - 1 : a) / FLOOR_CEILING_STEP) *
            FLOOR_CEILING_STEP
        );
    }

    public static final int FLOOR_CEILING_STEP = 1000;
    public static final Operation FLOOR = unary("floor", 1, Operations::floor);
    public static final Operation CEILING = unary(
        "ceiling",
        1,
        Operations::ceiling
    );

    // === Set, Clear

    @SuppressWarnings("IntegerMultiplicationImplicitCastToLong")
    public static final Operation SET = binary(
        "set",
        202,
        (a, b) -> a | (1 << b)
    );

    @SuppressWarnings("IntegerMultiplicationImplicitCastToLong")
    public static final Operation CLEAR = binary(
        "clear",
        202,
        (a, b) -> a & ~(1 << b)
    );

    // === Pow, Log
    public static final Operation POW_O = binary("**", 2402, (a, b) ->
        b < 0
            ? 1
            : BigInteger.valueOf(a)
                  .modPow(BigInteger.valueOf(b), BigInteger.valueOf(1L << 32))
                  .intValue()
    );
    public static final Operation LOG_O = binary("//", 2402, (a, b) ->
        a == 0 && b > 0
            ? Integer.MIN_VALUE
            : a <= 0 || b <= 0 || (a == 1 && b == 1)
                ? 0
                : a > 1 && b == 1
                    ? Integer.MAX_VALUE
                    : LongStream.iterate(b, v -> v <= a, v -> v * b).count()
    );

    private static final Reason INVALID_POW = new Reason("Invalid power");
    public static final Operation POW = binary("**", 2402, Operations::powC);

    private static long powC(final long a, final long b) {
        if (b < 0 || (a == 0 && b == 0)) {
            return INVALID_POW.error();
        }
        if (Math.abs(a) > 1 && b > 32) {
            return Reason.OVERFLOW.error();
        }
        final BigInteger result = BigInteger.valueOf(a).pow((int) b);
        if (
            result.compareTo(BigInteger.valueOf(Integer.MIN_VALUE)) < 0 ||
            BigInteger.valueOf(Integer.MAX_VALUE).compareTo(result) < 0
        ) {
            return Reason.OVERFLOW.error();
        }
        return result.intValue();
    }

    private static final Reason INVALID_LOG = new Reason("Invalid log");
    public static final Operation LOG = binary("//", 2402, (a, b) ->
        a <= 0 || b <= 1
            ? INVALID_LOG.error()
            : (int) (Math.log(a) / Math.log(b))
    );

    // Pow2, Log2

    private static final Reason NEG_LOG = new Reason(
        "Logarithm of negative value"
    );
    public static final Operation LOG_2 = unary(
        "log₂",
        1,
        NEG_LOG.less(1, a -> (long) (Math.log(a) / Math.log(2)))
    );

    private static final Reason NEG_POW = new Reason(
        "Exponentiation to negative power"
    );
    public static final Operation POW_2 = unary(
        "pow₂",
        1,
        NEG_POW.less(0, Reason.OVERFLOW.greater(31, a -> (long) Math.pow(2, a)))
    );

    // === High, Low
    public static final Operation HIGH = unary("high", 1, v ->
        Integer.highestOneBit((int) v)
    );
    public static final Operation LOW = unary("low", 1, v ->
        Integer.lowestOneBit((int) v)
    );

    // === Common

    private Operations() {}

    public static Operation unary(
        final String name,
        final int priority,
        final LongUnaryOperator op
    ) {
        return unary(name, priority, (a, c) -> op.applyAsLong(a));
    }

    public static Operation unary(
        final String left,
        final String right,
        final LongUnaryOperator op
    ) {
        return unary(left, right, (a, c) -> op.applyAsLong(a));
    }

    public static Operation unary(
        final String name,
        final int priority,
        final BiFunction<Long, LongToIntFunction, Long> op
    ) {
        return tests -> tests.unary(name, priority, op);
    }

    public static Operation unary(
        final String left,
        final String right,
        final BiFunction<Long, LongToIntFunction, Long> op
    ) {
        return tests -> tests.unary(left, right, op);
    }

    public static Operation binary(
        final String name,
        final int priority,
        final LongBinaryOperator op
    ) {
        return tests -> tests.binary(name, priority, op);
    }

    public static <E extends ToMiniString, C> Operation kind(
        final ExpressionKind<E, C> kind,
        final ParserTestSet.Parser<E> parser
    ) {
        return factory -> factory.kind(kind, parser);
    }

    @FunctionalInterface
    public interface Operation extends Consumer<ParserTester> {}
}