public class Benchmark {
    public static int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static int fibonacciIterative(int n) {
        if (n <= 1) {
            return n;
        }
        int a = 0;
        int b = 1;
        for (int i = 2; i <= n; i++) {
            int temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }

    public static int countPrimes(int limit) {
        int count = 0;
        for (int n = 2; n <= limit; n++) {
            boolean isPrime = true;
            for (int i = 2; i * i <= n; i++) {
                if (n % i == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                count++;
            }
        }
        return count;
    }

    public static long sumLoop(int iterations) {
        long sum = 0L;
        for (int i = 0; i < iterations; i++) {
            sum = sum + i;
        }
        return sum;
    }

    public static int arraySum(int size) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = i;
        }
        int sum = 0;
        for (int ii = 0; ii < size; ii++) {
            sum = sum + arr[ii];
        }
        return sum;
    }

    public static int arrayReverse(int size) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = i;
        }
        for (int ii = 0; ii < size / 2; ii++) {
            int temp = arr[ii];
            arr[ii] = arr[size - 1 - ii];
            arr[size - 1 - ii] = temp;
        }
        return arr[0];
    }

    public static int nestedLoops(int n) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                sum = sum + i + j;
            }
        }
        return sum;
    }

    public static int factorial(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }

    public static int ackermann(int m, int n) {
        if (m == 0) {
            return n + 1;
        }
        if (n == 0) {
            return ackermann(m - 1, 1);
        }
        return ackermann(m - 1, ackermann(m, n - 1));
    }

    public static int identity(int x) {
        return x;
    }

    public static int methodCallOverhead(int iterations) {
        int sum = 0;
        for (int i = 0; i < iterations; i++) {
            sum = sum + identity(i);
        }
        return sum;
    }

    public static long arithmeticOps(int iterations) {
        long result = 0L;
        for (int i = 1; i < iterations; i++) {
            result = result + i * 2 - i / 2 + i % 7;
        }
        return result;
    }

    public static int conditionalBranching(int iterations) {
        int sum = 0;
        for (int i = 0; i < iterations; i++) {
            if (i % 2 == 0) {
                sum = sum + i;
            } else {
                sum = sum - i;
            }
        }
        return sum;
    }

    public static int complexConditions(int iterations) {
        int count = 0;
        for (int i = 0; i < iterations; i++) {
            if (i % 3 == 0 && i % 5 == 0) {
                count = count + 1;
            } else if (i % 3 == 0) {
                count = count + 2;
            } else if (i % 5 == 0) {
                count = count + 3;
            }
        }
        return count;
    }

    public static int matrixMultiply(int size) {
        int[][] a = new int[size][size];
        int[][] b = new int[size][size];
        int[][] c = new int[size][size];

        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                a[i][j] = i + j;
                b[i][j] = i - j;
            }
        }

        for (int ii = 0; ii < size; ii++) {
            for (int jj = 0; jj < size; jj++) {
                int sum = 0;
                for (int kk = 0; kk < size; kk++) {
                    sum = sum + a[ii][kk] * b[kk][jj];
                }
                c[ii][jj] = sum;
            }
        }

        return c[0][0];
    }

    public static int bubbleSort(int size) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = size - i;
        }

        for (int ii = 0; ii < size - 1; ii++) {
            for (int jj = 0; jj < size - ii - 1; jj++) {
                if (arr[jj] > arr[jj + 1]) {
                    int temp = arr[jj];
                    arr[jj] = arr[jj + 1];
                    arr[jj + 1] = temp;
                }
            }
        }

        return arr[0];
    }

    public static int main() {
        System.out.println("=== Rava Comprehensive Benchmark Suite ===");

        long start = System.nanoTime();
        int fib30 = fibonacci(30);
        long end = System.nanoTime();
        long fibTime = (end - start) / 1000000;
        System.out.print("Fibonacci(30) recursive = ");
        System.out.println(fib30);
        System.out.print("Time: ");
        System.out.print(fibTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int fib40iter = fibonacciIterative(40);
        end = System.nanoTime();
        long fibIterTime = (end - start) / 1000000;
        System.out.print("Fibonacci(40) iterative = ");
        System.out.println(fib40iter);
        System.out.print("Time: ");
        System.out.print(fibIterTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int primes = countPrimes(100000);
        end = System.nanoTime();
        long primeTime = (end - start) / 1000000;
        System.out.print("Primes up to 100000 = ");
        System.out.println(primes);
        System.out.print("Time: ");
        System.out.print(primeTime);
        System.out.println(" ms");

        start = System.nanoTime();
        long sumResult = sumLoop(10000000);
        end = System.nanoTime();
        long sumTime = (end - start) / 1000000;
        System.out.print("Sum 0..10000000 = ");
        System.out.println(sumResult);
        System.out.print("Time: ");
        System.out.print(sumTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int arrSum = arraySum(1000000);
        end = System.nanoTime();
        long arrSumTime = (end - start) / 1000000;
        System.out.print("Array sum (1M elements) = ");
        System.out.println(arrSum);
        System.out.print("Time: ");
        System.out.print(arrSumTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int arrRev = arrayReverse(1000000);
        end = System.nanoTime();
        long arrRevTime = (end - start) / 1000000;
        System.out.print("Array reverse (1M elements) = ");
        System.out.println(arrRev);
        System.out.print("Time: ");
        System.out.print(arrRevTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int nested = nestedLoops(1000);
        end = System.nanoTime();
        long nestedTime = (end - start) / 1000000;
        System.out.print("Nested loops (1000x1000) = ");
        System.out.println(nested);
        System.out.print("Time: ");
        System.out.print(nestedTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int fact = factorial(15);
        end = System.nanoTime();
        long factTime = (end - start) / 1000000;
        System.out.print("Factorial(15) recursive = ");
        System.out.println(fact);
        System.out.print("Time: ");
        System.out.print(factTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int ack = ackermann(3, 6);
        end = System.nanoTime();
        long ackTime = (end - start) / 1000000;
        System.out.print("Ackermann(3, 6) = ");
        System.out.println(ack);
        System.out.print("Time: ");
        System.out.print(ackTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int methodCall = methodCallOverhead(10000000);
        end = System.nanoTime();
        long methodCallTime = (end - start) / 1000000;
        System.out.print("Method calls (10M) = ");
        System.out.println(methodCall);
        System.out.print("Time: ");
        System.out.print(methodCallTime);
        System.out.println(" ms");

        start = System.nanoTime();
        long arith = arithmeticOps(10000000);
        end = System.nanoTime();
        long arithTime = (end - start) / 1000000;
        System.out.print("Arithmetic ops (10M) = ");
        System.out.println(arith);
        System.out.print("Time: ");
        System.out.print(arithTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int cond = conditionalBranching(10000000);
        end = System.nanoTime();
        long condTime = (end - start) / 1000000;
        System.out.print("Conditional branches (10M) = ");
        System.out.println(cond);
        System.out.print("Time: ");
        System.out.print(condTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int complex = complexConditions(10000000);
        end = System.nanoTime();
        long complexTime = (end - start) / 1000000;
        System.out.print("Complex conditions (10M) = ");
        System.out.println(complex);
        System.out.print("Time: ");
        System.out.print(complexTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int matrix = matrixMultiply(50);
        end = System.nanoTime();
        long matrixTime = (end - start) / 1000000;
        System.out.print("Matrix multiply (50x50) = ");
        System.out.println(matrix);
        System.out.print("Time: ");
        System.out.print(matrixTime);
        System.out.println(" ms");

        start = System.nanoTime();
        int bubble = bubbleSort(5000);
        end = System.nanoTime();
        long bubbleTime = (end - start) / 1000000;
        System.out.print("Bubble sort (5000 elements) = ");
        System.out.println(bubble);
        System.out.print("Time: ");
        System.out.print(bubbleTime);
        System.out.println(" ms");

        System.out.println("=== Benchmark Complete ===");
        return 0;
    }
}