Jetbrains Academy- Amazing Numbers Project- Sunny and Square Numbers

/******************************************************************************

                            Online Java Compiler.
                Code, Compile, Run and Debug java program online.
Write your code in this editor and press "Run" button to execute it.

*******************************************************************************/

import java.util.Scanner;
import java.util.Arrays;

public class Main {

    enum ParameterTypes {
        EVEN,
        ODD,
        BUZZ,
        DUCK,
        PALINDROMIC,
        GAPFUL;
        SPY,
        SQUARE,
        SUNNY
    }

    public static void main(String[] args) {
        System.out.println("Welcome to Amazing Numbers!");
        System.out.println(" ");
        instructions();
        requestPrompt();
    }

    public static void instructions() {
        System.out.println("Supported requests:\n" +
                "- enter a natural number to know its properties;\n" +
                "- enter two natural numbers to obtain the properties of the list:\n" +
                "  * the first parameter represents a starting number;\n" +
                "  * the second parameters show how many consecutive numbers are to be processed;\n" +
                "- two natural numbers and two properties to search for; \n" +
                "- separate the parameters with one space;\n" +
                "- enter 0 to exit.");
    }

    public static void requestPrompt() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a request:");
        String str = scanner.nextLine();

        while (!str.equals("0")) {
            String[] strArray = str.split(" ");

            if (strArray.length == 4) {
                numbersWithTwoParameters(strArray);
            }
            else if (strArray.length == 3) {
                numbersWithOneParameter(strArray);
            }
            else if (strArray.length == 2) {
                twoNumbers(strArray);
                }
             else {
                oneNumber(strArray);
            }

            System.out.println("Enter a request:");
            str = scanner.nextLine();
        }

        System.out.println("Goodbye!");

    }

    public static void numbersWithOneParameter(String[] strArray) {
        long naturalNumber = Long.parseLong(strArray[0]);
        long counter = Long.parseLong(strArray[1]);
        String parameter = strArray[2];



        if (naturalNumber < 0) {
            System.out.println("The first parameter should be a natural number or zero.");
        } else if (counter <= 0) {
            System.out.println("second parameter should be a natural number");
        } else if (doesParamExist(parameter) == false)
         {
            System.out.println("The property [" + parameter +  "] is wrong. \n" +
            "Available properties: [BUZZ, DUCK, PALINDROMIC, GAPFUL, SPY, EVEN, ODD]");
        }  else {
            switch (parameter.toLowerCase()) {
                case "even": {
                    for (int i = 0; i < counter; i++) {
                        while(!evenNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "odd": {
                    for (int i = 0; i < counter; i++) {
                        while(!oddNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "buzz": {
                    for (int i = 0; i < counter; i++) {
                         while(!buzzNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "duck": {
                    for (int i = 0; i < counter; i++) {
                        while(!duckNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "palindromic": {
                    for (int i = 0; i < counter; i++) {
                        while(!palindromicNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "gapful": {
                    for (int i = 0; i < counter; i++) {
                        while(!gapfulNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "spy": {
                    for (int i = 0; i < counter; i++) {
                        while(!spyNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "square" {
                    for (int i = 0; i < counter; i++) {
                        while(!squareNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
            }
        }
    }

    public static void numbersWithTwoParameters(String[] strArray) {
        long naturalNumber = Long.parseLong(strArray[0]);
        long counter = Long.parseLong(strArray[1]);
        String parameter1 = strArray[2];
        String parameter2 = strArray[3];



        if (naturalNumber < 0) {
            System.out.println("The first parameter should be a natural number or zero.");
        } else if (counter <= 0) {
            System.out.println("second parameter should be a natural number");
        } else if (doesParamExist(parameter1) == false && doesParamExist(parameter2) == true) {
            System.out.println("The property [" + parameter1 +  "] is wrong. \n" +
            "Available properties: [BUZZ, DUCK, PALINDROMIC, GAPFUL, SPY, EVEN, ODD]");
        } else if (doesParamExist(parameter1) == true && doesParamExist(parameter2) == false) {
            System.out.println("The property [" + parameter1 +  "] is wrong. \n" +
            "Available properties: [BUZZ, DUCK, PALINDROMIC, GAPFUL, SPY, EVEN, ODD]");
        } else if (doesParamExist(parameter1) == false && doesParamExist(parameter2) == false) {
            System.out.println("The properties [" + parameter1 + " " + parameter2  "] are wrong. \n" +
            "Available properties: [BUZZ, DUCK, PALINDROMIC, GAPFUL, SPY, EVEN, ODD]");
        } else if (parameter1.toLowerCase() == "odd" && parameter2.toLowerCase() == "even" || parameter2.toLowerCase() == "odd" && parameter1.toLowerCase() == "even" ||
            parameter1.toLowerCase() == "square" && parameter2.toLowerCase() == "sunny" ||  parameter2.toLowerCase() == "square" && parameter1.toLowerCase() == "sunny" ||
            parameter1.toLowerCase() == "spy" && parameter2.toLowerCase() == "duck" || parameter2.toLowerCase() == "spy" && parameter1.toLowerCase() == "duck") {
            System.out.println("The request contains mutually exclusive properties: [SQUARE, SUNNY] \n" +
            "There are no numbers with these properties.")
        }
          else {


        }
    }

    public static void numberProppertiesChecker(String parameter, long naturalNumber, long counter) {
        switch (parameter1.toLowerCase()) {
                case "even": {
                    for (int i = 0; i < counter; i++) {
                        while(!evenNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "odd": {
                    for (int i = 0; i < counter; i++) {
                        while(!oddNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "buzz": {
                    for (int i = 0; i < counter; i++) {
                         while(!buzzNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "duck": {
                    for (int i = 0; i < counter; i++) {
                        while(!duckNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "palindromic": {
                    for (int i = 0; i < counter; i++) {
                        while(!palindromicNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "gapful": {
                    for (int i = 0; i < counter; i++) {
                        while(!gapfulNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
                case "spy": {
                    for (int i = 0; i < counter; i++) {
                        while(!spyNumber(naturalNumber)) {
                            naturalNumber++;
                        }
                        printNumberProperties(naturalNumber);
                        naturalNumber++;
                    }
                    break;
                }
            }
        }

    public static boolean doesParamExist(String parameter) {
        String[] paramArray = {"even", "odd", "buzz", "duck", "palindromic", "gapful", "spy"};
        boolean check;
        for (String checker : paramArray) {
            if (checker.equals(parameter.toLowerCase())) {
                return true;
            }
        }
        return false;
    }

    public static void twoNumbers(String[] strArray) {

        long naturalNumber = Long.parseLong(strArray[0]);
        long counter = Long.parseLong(strArray[1]);

        if (naturalNumber < 0) {
            System.out.println("The first parameter should be a natural number or zero.");
        } else if (counter <= 0) {
            System.out.println("second parameter should be a natural number");
        } else {
            for(int i = 0; i < counter; i++) {
                printNumberProperties(naturalNumber);
                naturalNumber++;
            }
        }
    }

    public static void oneNumber(String[] strArray) {
        long naturalNumber = Long.parseLong(strArray[0]);

        if (naturalNumber < 0) {
            System.out.println("The first parameter should be a natural number or zero.");
        } else {
            System.out.println("Properties of " + naturalNumber);
            System.out.println("even: " + evenNumber(naturalNumber));
            System.out.println("odd: " + oddNumber(naturalNumber));
            System.out.println("buzz: " + buzzNumber(naturalNumber));
            System.out.println("duck: " + duckNumber(naturalNumber));
            System.out.println("palindromic: " + palindromicNumber(naturalNumber));
            System.out.println("gapful: " + gapfulNumber(naturalNumber));
            System.out.println("spy: " + spyNumber(naturalNumber));
        }
    }

    public static void printNumberProperties(long naturalNumber) {
            System.out.print(naturalNumber + " is ");
            if (evenNumber(naturalNumber)) System.out.print("even, ");
            if (oddNumber(naturalNumber)) System.out.print("odd, ");
            if (buzzNumber(naturalNumber)) System.out.print("buzz, ");
            if (duckNumber(naturalNumber)) System.out.print("duck, ");
            if (palindromicNumber(naturalNumber)) System.out.print("palindromic, ");
            if (gapfulNumber(naturalNumber)) System.out.print("gapful, ");
            if (spyNumber(naturalNumber)) System.out.print("spy");
            System.out.print("\n");
    }

    public static boolean evenNumber(long x) {
        if (x % 2 == 0) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean oddNumber(long x) {
        if (x % 2 != 0) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean buzzNumber(long x) {
        if (x == 7) {
            return true;
        } else if (x % 7 == 0 && x % 10 != 7) {
            return true;
        } else if (x % 7 == 0 && x % 10 == 7) {
            return true;
        } else if (x % 7 != 0 && x % 10 == 7) {
            return true;
        } else {
            return false;
        }
    }

    public static boolean duckNumber(long x) {
        String xString = Long.toString(x);
        if (xString.charAt(0) == 0) {
            return false;
        } else {
            char[] charArray = xString.toCharArray();

            for (char i : charArray) {
                if (i == 48) {
                    return true;
                }
            }
            return false;
        }

    }

    public static boolean palindromicNumber(long x) {

        String xString = Long.toString(x);
        char[] charArray = xString.toCharArray();
        char[] reversedCharArray = new char[charArray.length];
        int count = 0;

        for (int i = charArray.length; i > 0; --i) {
            reversedCharArray[count] = charArray[i - 1];
            ++count;
        }
        return Arrays.equals(charArray, reversedCharArray);
    }

    public static boolean gapfulNumber(long x) {
        char[] ch = Long.toString(x).toCharArray();

        if (ch.length <= 2) {
            return false;
        }

        long ch1 = Character.getNumericValue(ch[0]);
        long ch2 = Character.getNumericValue(ch[ch.length - 1]);
        long x2 = ch1 * 10 + ch2;

        return x % x2 == 0;
    }

    public static boolean spyNumber(long x) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(x);
        char[] charArr = stringBuilder.toString().toCharArray();

        int stringLength = stringBuilder.length();
        int sum = Character.getNumericValue(charArr[0]), product = Character.getNumericValue(charArr[0]);

        for(int i = 1; i < charArr.length; i++) {
            sum += Character.getNumericValue(charArr[i]);
            product = product * (Character.getNumericValue(charArr[i]));
        }

        return sum == product;
    }

    public static boolean squareNumber(long x) {
        double sqrtX = Math.sqrt(x);
        return sqrtX - Math.floor(sqrtX) == 0;
    }
    public static boolean sunnyNumber(long x) {
        double sqrtX = Math.sqrt(x+1);
        return sqrtX - Math.floor(sqrtX) == 0;
    }
}