package de.sanacorp.security.persistence.base.inclause;

import java.util.function.IntBinaryOperator;
import org.hibernate.internal.util.MathHelper;

public class HHH_16589 {
  public static void main(String[] args) {
    System.out.println("| bindValueCount | inExprLimit | originalResult | proposalResult |");
    System.out.println("|----------------|-------------|----------------|----------------|");

    IntBinaryOperator original = HHH_16589::hibernate_6_2_2_Final;
    IntBinaryOperator proposal = HHH_16589::calculateLastInClauseSize;

    compare(1, 0, original, proposal);
    compare(2, 0, original, proposal);
    compare(3, 0, original, proposal);
    compare(4, 0, original, proposal);
    compare(5, 0, original, proposal);
    compare(1000, 0, original, proposal);
    compare((1 << 30) - 1, 0, original, proposal);
    compare(1 << 30, 0, original, proposal);
    compare((1 << 30) + 1, 0, original, proposal);
    compare(Integer.MAX_VALUE - 1, 0, original, proposal);
    compare(Integer.MAX_VALUE, 0, original, proposal);

    compare(1, 1000, original, proposal);

    compare(7, 1000, original, proposal);
    compare(8, 1000, original, proposal);

    compare(511, 1000, original, proposal);
    compare(512, 1000, original, proposal);
    compare(513, 1000, original, proposal);

    compare(999, 1000, original, proposal);
    compare(1000, 1000, original, proposal);
    compare(1001, 1000, original, proposal);

    compare(1008, 1000, original, proposal);

    compare(1023, 1000, original, proposal);
    compare(1024, 1000, original, proposal);
    compare(1025, 1000, original, proposal);

    compare(1511, 1000, original, proposal);
    compare(1512, 1000, original, proposal);
    compare(1513, 1000, original, proposal);

    compare(1999, 1000, original, proposal);
    compare(2000, 1000, original, proposal);
    compare(2001, 1000, original, proposal);

    compare(2511, 1000, original, proposal);
    compare(2512, 1000, original, proposal);
    compare(2513, 1000, original, proposal);

    compare(2999, 1000, original, proposal);
    compare(3000, 1000, original, proposal);
    compare(3001, 1000, original, proposal);

    compare(Integer.MAX_VALUE - 1, 1000, original, proposal);
    compare(Integer.MAX_VALUE, 1000, original, proposal);
  }

  public static void compare(int bindValueCount, int inExprLimit, IntBinaryOperator original,
      IntBinaryOperator proposal) {
    int originalResult = original.applyAsInt(bindValueCount, inExprLimit);
    int proposalResult = proposal.applyAsInt(bindValueCount, inExprLimit);
    System.out
        .println("| " + bindValueCount + " | " + inExprLimit + " | " + originalResult + " | " + proposalResult + " |");
  }

  private static int hibernate_6_2_2_Final(int bindValueCount, int inExprLimit) {
    int bindValueMaxCount = bindValueCount;
    // bindValueCount: 1005
    // bindValuePaddingCount: 1024
    int bindValuePaddingCount = MathHelper.ceilingPowerOfTwo(bindValueCount);

    // inExprLimit: 1000
    if (inExprLimit > 0) {
      if (bindValuePaddingCount > inExprLimit) {
        // bindValueCount % inExprLimit: 5
        // bindValuePaddingCount: 8
        if (bindValueCount < inExprLimit) {
          bindValueMaxCount = inExprLimit;
        } else {
          bindValueMaxCount = MathHelper.ceilingPowerOfTwo(bindValueCount % inExprLimit);
        }
      } else if (bindValueCount < bindValuePaddingCount) {
        bindValueMaxCount = bindValuePaddingCount;
      }
    } else if (bindValueCount < bindValuePaddingCount) {
      bindValueMaxCount = bindValuePaddingCount;
    }
    return bindValueMaxCount;
  }

  private static int calculateLastInClauseSize(int bindValueCount, int inExprLimit) {
    if (inExprLimit > 0) {
      int lastInClauseSize = bindValueCount % inExprLimit;
      int lastInClauseSizeWithPadding = ceilingPowerOfTwoFixed(lastInClauseSize);
      return Math.min(inExprLimit, lastInClauseSizeWithPadding);
    } else {
      return ceilingPowerOfTwoFixed(bindValueCount);
    }
  }

  // This should probably be done in MathHelper already.
  // If values above 1073741824 (2^30) are not of a concern we could just use MathHelper directly.
  private static int ceilingPowerOfTwoFixed(int value) {
    int result = MathHelper.ceilingPowerOfTwo(value);
    if (result < value) { // Overflow
      return Integer.MAX_VALUE;
    }
    return result;
  }
}