/* javase demo for test */
package com.example.javase;

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.text.SimpleDateFormat;
import java.io.*;
import java.util.*;
import java.util.function.*;
import java.util.Timer;
import java.util.TimerTask;

@FunctionalInterface
interface ThrowingConsumer<T> {
    void accept(T t) throws Exception;
}

class Animal {
    public int leg;

    {
        leg = 16;
    }

    public Animal() {
        System.out.println("Animal cs");
    }

    void makeNoise() {
        System.out.println("Generic animal noise");
    }

    int hasLegs() {
        if (leg > 0) {
            return leg;
        }
        return 4;
    }
}

class Dog extends Animal {
    @Override
    void makeNoise() {
        System.out.println("Bark!");
    }

    @Override
    int hasLegs() {
        return 3;
    }
}


public class Main {

    private static int timerCount = 0;
    private static final int aa = 11;
    private static final String b = "www";

    private String c = "eee";

    {
        c = "ccc";
        c = "qqq";
        c = "rrr";

        int d = 8;
    }

    static class Cat extends Animal {
        static {
            System.out.println("Cat static!");
        }

        {
            leg = 111;
        }

        @Override
        void makeNoise() {
            System.out.println("Meow!");
        }

        @Override
        int hasLegs() {
            return leg;
        }
    }

    public enum ItemEnum {

        HOME("Home"), PRODUCTS("Products"), COMPANY("Company");

        private final String title;

        ItemEnum(String title) {
          this.title = title;
        }

        @Override
        public String toString() {
          return title;
        }
    }

    private static double getPercentage(double value, int min, int max) {
        if (value > max) {
            return 1.0;
        }
        if (value < min) {
            return 0.0;
        }

        double ret = (value - min) / (max - min);
        if (ret <= 0.0601f && ret > 0.0401f) {
            ret = 0.05;
        } else if (ret <= 0.0401f && ret > 0.0201f) {
            ret = 0.03;
        } else if (ret <= 0.0201f && ret > 0.0061f) {
            ret = 0.01;
        } else if (ret <= 0.0061f) {
            ret = 0.0;
        }
        return ret;
    }

    private static double getPercentageWithThrow(double value, int min, int max) throws Exception {
        if (value > max) {
            return 1.0;
        }
        if (value < min) {
            return 0.0;
        }

        if (111 == 111) {
            throw new Exception("Throw an Exception!");
        }

        double ret = (value - min) / (max - min);
        if (ret <= 0.0601f && ret > 0.0401f) {
            ret = 0.05;
        } else if (ret <= 0.0401f && ret > 0.0201f) {
            ret = 0.03;
        } else if (ret <= 0.0201f && ret > 0.0061f) {
            ret = 0.01;
        } else if (ret <= 0.0061f) {
            ret = 0.0;
        }
        return ret;
    }

    private static void recurAddInt(int a, int b) {
        int sum = a + b;
        if (sum < 100) {
            System.out.println("recurAddInt sum pre: " + sum);
            recurAddInt(sum, b);
            System.out.println("recurAddInt sum after: " + sum);
        }
    }

    private static int addInt(int a, int b) {
        int ret = a + b;
        try {
            System.out.println("addInt getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
            return ret;
        } catch (Exception e) {
            e.printStackTrace();
            return ret;
        } finally {
            System.out.println("in addInt finally 1");
            System.out.println("in addInt finally 2");
            System.out.println("in addInt finally 3");
        }
    }

    private static int addInt2(int a, int b) {
        int ret = a + b;
        try {
            System.out.println("addInt2 getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
            return ret;
        } catch (Exception e) {
            e.printStackTrace();
            try {
                System.out.println("addInt2 inner catch block getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
            } catch (Exception e2) {
                e2.printStackTrace();
            } finally {
                System.out.println("in addInt2 inner catch block finally 1");
                System.out.println("in addInt2 inner catch block finally 2");
                System.out.println("in addInt2 inner catch block finally 3");
                return ret;
            }
        } finally {
            System.out.println("in addInt2 finally 1");
            System.out.println("in addInt2 finally 2");
            System.out.println("in addInt2 finally 3");
            try {
                System.out.println("addInt2 inner finally block getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
            } catch (Exception e2) {
                e2.printStackTrace();
            } finally {
                System.out.println("in addInt2 inner finally block finally 1");
                System.out.println("in addInt2 inner finally block finally 2");
                System.out.println("in addInt2 inner finally block finally 3");
            }
        }
    }

    private static void addIntVoid(int a, int b) {
        int ret = a + b;
        try {
            System.out.println("addIntVoid getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
            System.out.println("ret addIntVoid try: " + ret);
            try {
                System.out.println("addIntVoid inner try block getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
                System.out.println("ret addIntVoid inner try block try: " + ret);
                return;
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("ret catch: " + ret);
                return;
            } finally {
                System.out.println("in addIntVoid inner try block finally 1");
                System.out.println("ret addIntVoid inner try block finally: " + ret);
                System.out.println("in addIntVoid inner try block finally 2");
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("ret catch: " + ret);
            return;
        } finally {
            System.out.println("in addIntVoid finally 1");
            System.out.println("ret addIntVoid finally: " + ret);
            System.out.println("in addIntVoid finally 2");
        }
    }

    private static void addIntVoid2(int a, int b) {
        int ret = a + b;
        try {
            System.out.println("addIntVoid2 getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
            System.out.println("ret addIntVoid2 try: " + ret);
            try {
                System.out.println("addIntVoid2 inner try block getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
                System.out.println("ret addIntVoid2 inner try block try: " + ret);
                return;
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("ret addIntVoid2 inner try block catch: " + ret);
                return;
            } finally {
                System.out.println("in addIntVoid2 inner try block finally 1");
                System.out.println("ret addIntVoid2 inner try block finally: " + ret);
                System.out.println("in addIntVoid2 inner try block finally 2");
                return;
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("ret addIntVoid2 catch: " + ret);
            return;
        } finally {
            System.out.println("in addIntVoid2 finally 1");
            System.out.println("ret addIntVoid2 finally: " + ret);
            System.out.println("in addIntVoid2 finally 2");
            return;
        }
    }

    static class Counter {
        private int count = 0;

        public void increment() {
            synchronized (this) {
                count++;
            }
        }

        public synchronized void decrement() {
            count--;
        }

        public Object getLock() {
            return this;
        }

        public int getCount() {
            synchronized (getLock()) {
                if (count < 0) {
                    return 0;
                }
                return count;
            }
        }
    }

    public static void main(String[] args) throws Exception {

        // Use try-with-resources
        try (BufferedReader reader = new BufferedReader(new FileReader("/no-such-file"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Error reading the file: " + e.getMessage());
        }

        String today = "Friday";
        String dayType = switch (today) {
            case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> "Weekday";
            case "Saturday", "Sunday" -> "Weekend";
            default -> "Invalid day";
        };
        System.out.println(today + " is: " + dayType);

        Counter counter = new Counter();

        String operation = "increment";  // try "increment", "decrement", "show"

        switch (operation) {
            case "increment":
                counter.increment();
                System.out.println("Counter incremented.");
                break;
            case "decrement":
                counter.decrement();
                System.out.println("Counter decremented.");
                break;
            case "show":
                System.out.println("Current count: " + counter.getCount());
                break;
            default:
                System.out.println("Unknown operation.");
        }

        System.out.println("Final count: " + counter.getCount());

        recurAddInt(13, 17);

        // boolean aaeee = true;
        // if (aaeee) {
        //     return;
        // }

        for (int i = 0; i < 2; i++) {
            System.out.println("main for outer i: " + i);
            for (int j = 0; j < 3; j++) {
                System.out.println("main for inner j: " + j);
            }
        }

        new Thread(() -> {
            while (true) {
                try {
                    System.out.println("addInt: " + addInt(1, 2));
                    Thread.sleep(8); // print every 8ms
                    addIntVoid(1, 2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("new thread xxx");
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                try {
                    System.out.println("addInt2: " + addInt2(1, 2));
                    Thread.sleep(10); // print every 8ms
                    addIntVoid2(1, 2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("new thread yyy");
                }
            }
        }).start();

        // boolean bolleanGo = false;
        // if (!bolleanGo) {
        //     return;
        // }

        Main mainObj = new Main();
        mainObj.add(1, 2);
        Main.getInt(3);

        int[][] array2D = {
               {1, 2, 3},
               {4, 5, 6},
               {7, 8, 9}
           };

        System.out.println("2 di: " + Arrays.deepToString(array2D));

        if (111 == 222) {
            throw new Exception("An Exception won't be thrown:)");
        }

        boolean go = false;
        while (go) {
            throw new Exception("An Exception won't be thrown:)");
        }

        while (go)
            throw new Exception("An Exception won't be thrown:)");

        do {
            System.out.println("in block of do while");
        } while (1 == 2);

        do
            do
                do
                    System.out.println("in do while without block");
                while (1 == 2);
            while (1 == 2);
        while (1 == 2);

        Main main = new Main();
        System.out.println("Main object: " + main + ", getPercentage: " + main.getPercentage(3, 1 , 5));

        try {
            System.out.println("thread timer getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("in finally start");
            System.out.println("in finally...");
            System.out.println("in finally end");
        }

        if (111 == 222) {
            return;
        }

        byte[] byteArray = new byte[100]; // assume byteArray has 100 elements
        byte[] last50Bytes = Arrays.copyOfRange(byteArray, 50, 100);
        System.out.println(Arrays.toString(last50Bytes));

        Animal aa = new Animal() {
            {
                leg = 1;
            }

            @Override
            void makeNoise() {
                System.out.println("inner Bark!");
            }

            @Override
            int hasLegs() {
                System.out.println("inner legs: " + leg);
                return leg;
            }
        };

        aa.makeNoise();
        System.out.println("aa legs: " + aa.hasLegs());

        // Lambda ..start
        // Lambda 1: Check if a number is even
        Predicate<Integer> isEven = num -> num % 2 == 0;
        System.out.println("Is 4 even? " + isEven.test(4)); // Output: Is 4 even? true

        // Lambda 2: Multiply two integers
        BinaryOperator<Integer> multiply = (a, b) -> a * b;
        System.out.println("5 multiplied by 6 is: " + multiply.apply(5, 6)); // Output: 5 multiplied by 6 is: 30

        // Lambda 3: Convert an integer to a string
        Function<Integer, String> convertToString = (Integer num) -> Integer.toString(num);
        System.out.println("Converted to string: " + convertToString.apply(15)); // Output: Converted to string: 15

        // Lambda 4: Print a string
        Consumer<String> print = str -> System.out.println("Printing: " + str);
        print.accept("Hello, world!"); // Output: Printing: Hello, world!

        // Lambda 5: Classify an integer as positive, negative, or zero
        Function<Integer, String> classify = (Integer num) -> {
            var res = (num > 0) ? "Positive" :
                    (num < 0) ? "Negative" :
                    "Zero";
            return res;
        };
        System.out.println("Classification of -5: " + classify.apply(-5)); // Output: Classification of -5: Negative

        // Lambda 6: Classify2: Classify an integer as positive, negative, or zero
        Function<Integer, String> classify2 = (Integer num) -> {
            return (num > 0) ? "Positive" :
                    (num < 0) ? "Negative" :
                    "Zero";
        };
        System.out.println("Classification of 10: " + classify2.apply(10)); // Output: Classification of 10: Positive
        System.out.println("Classification of 0: " + classify2.apply(0)); // Output: Classification of 0: Zero
        // Lambda ..end

        Animal a = new Animal(); // Create an Animal object
        System.out.println("xxxx legs: " + a.hasLegs());
        Animal b = new Dog(); // Create a Dog object
        Cat c = new Cat();

        Thread threadA = new Thread(() -> {
            while (true) {
                System.out.println("threadA");
                a.makeNoise(); // Calls Animal's makeNoise()
                try {
                    Thread.sleep(8); // print every 8ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        threadA.start();

        Thread threadB = new Thread(() -> {
            while (true) {
                System.out.println("threadB");
                b.makeNoise(); // Calls Dog's makeNoise()
                try {
                    Thread.sleep(15); // print every 15ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        threadB.start();

        Timer timer = new Timer();
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("timer");
                c.makeNoise(); // Calls Cat's makeNoise()
                try {
                    System.out.println("thread timer getPercentageWithThrow(3, 1 , 5): " + getPercentageWithThrow(3, 1 , 5));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // Lambda that throws a checked exception
                ThrowingConsumer<String> throwingConsumer = s -> {
                    if (s == null) {
                        throw new Exception("Input cannot be null");
                    }
                    System.out.println(s);
                };

                // Lambda that throws an unchecked exception
                Consumer<String> consumer = s -> {
                    if (s == null) {
                        throw new IllegalArgumentException("Input cannot be null");
                    }
                    System.out.println(s);
                };

                try {
                    throwingConsumer.accept(null);
                } catch (Exception e) {
                    System.out.println("Caught exception: " + e.getMessage());
                }

                try {
                    consumer.accept(null);
                } catch (IllegalArgumentException e) {
                    System.out.println("Caught exception: " + e.getMessage());
                }
                if (timerCount > 1) {
                    System.exit(1); // abort the whole process.
                }
                timerCount++;
            }
        }, 20, 20); // start after 20ms delay and then print every 20ms

       while (true) {
            System.out.println("hello world2: " + new SimpleDateFormat("yyyyMMdd.HHmmss").format(new Date()));
            System.out.println("hello aa: " + getPercentage(0.0201, 0, 1));
            // get the runtime MXBean
            RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
            // get the PID
            String processID = runtime.getName().split("@")[0];

            // print the PID
            System.out.println("The process ID is: " + processID);
            System.out.println("   -------");
            System.out.println("");

            a.makeNoise(); // Calls Animal's makeNoise()
            b.makeNoise(); // Calls Dog's makeNoise()
            c.makeNoise(); // Calls Cat's makeNoise()

            Thread.sleep(10);
       }
    }

    private int add(int a, int b) {
        return a+b;
    }

    private static int getInt(int a) {
        return a;
    }
}