import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.lang.*;
import java.io.*;

class Main {
    
    static String string1 = "Hello, World! OpenAI is amazing.";
    static String res1 = "amazing. is OpenAI World! Hello,";

    static String string2 = "Hello, World!";
    static String res2 = "Helo, Wrd!";

    static String string3 = "babad";
    static String res3 = "bab";

    static String string4 = "hello. how are you? i'm fine, thank you.";
    static String res4 = "Hello. How are you? I'm fine, thank you.";

    static String string5 = "racecar";
    static String res5 = "true";
    
    public static void main(String[] args) {
        
        //------ Primeiro Exercicio ------------------------

        String resultado = inverterPalavras(string1);
        System.out.println("Exercicio 1: Reverta a ordem das palavras nas frases, mantendo a ordem das palavras:");
        System.out.println("Entrada: " + string1);
        System.out.println("Resultado Esperado: " + res1);
        System.out.println("Resultado: " + resultado);
        System.out.println(res1.equals(resultado) ? "Resultados Iguais!":"Resultados Diferentes!");
        separador();


        //------ Segundo Exercicio ------------------------

        String resultado2 = removerDuplicados(string2);
        System.out.println("Exercício 2: Remova todos os caracteres duplicados da string abaixo:");
        System.out.println("Entrada: " + string2);
        System.out.println("Resultado Esperado: " + res2);
        System.out.println("Resultado: " + resultado2);
        System.out.println(res2.equals(resultado2) ? "Resultados Iguais!" : "Resultados Diferentes!");
        separador();


        //------ Terceiro Exercicio ------------------------

        String resultado3 = maiorPalindrome(string3);
        System.out.println("Exercício 3: Encontre a substring palíndroma mais longa na string abaixo:");
        System.out.println("Entrada: " + string3);
        System.out.println("Resultado Esperado: " + res3);
        System.out.println("Resultado: " + resultado3);
        System.out.println(res3.equals(resultado3) ? "Resultados Iguais!" : "Resultados Diferentes!");
        separador();


        //------ Quarto Exercicio ------------------------

        String resultado4 = capitalizeFrase(string4);
        System.out.println("Exercício 4: Coloque em maiúscula a primeira letra de cada frase na string:");
        System.out.println("Entrada: " + string4);
        System.out.println("Resultado Esperado: " + res4);
        System.out.println("Resultado: " + resultado4);
        System.out.println(res4.equals(resultado4) ? "Resultados Iguais!" : "Resultados Diferentes!");
        separador();


        //------ Quinto Exercicio ------------------------

        String resultado5 = anagramaPalindrome(string5);
        System.out.println("Exercício 5: Verifique se a string é um anagrama de um palíndromo:");
        System.out.println("Entrada: " + string5);
        System.out.println("Resultado Esperado: " + res5);
        System.out.println("Resultado: " + resultado5);
        System.out.println(res5.equals(resultado5) ? "Resultados Iguais!" : "Resultados Diferentes!");
        separador();
        
        
    }
    private static final String EMPTY_STRING_ERROR = "Entrada Invalida.";

    public static void separador(){
        System.out.println("------------------------------------------");
    }

    private static void validarEntrada(String valor) {
        if (valor == null || valor.isEmpty()) {
            throw new IllegalArgumentException(EMPTY_STRING_ERROR);
        }
    }

    public static String inverterPalavras(String sentence) {
        validarEntrada(sentence);

        return Arrays.stream(sentence.split(" "))
                .reduce((word1, word2) -> word2 + " " + word1)
                .orElse("");
    }

    public static String removerDuplicados(String string) {
        validarEntrada(string);

        return string.chars()
                .distinct()
                .collect(StringBuilder::new, (sb, c) -> sb.append((char) c), StringBuilder::append)
                .toString();
    }

    public static String maiorPalindrome(String string) {
        validarEntrada(string);

        Optional<String> longestPalindrome = IntStream.range(0, string.length())
                .mapToObj(i -> IntStream.rangeClosed(i, string.length())
                        .mapToObj(j -> string.substring(i, j)))
                .flatMap(Function.identity())
                .filter(s -> {
                    String reversed = new StringBuilder(s).reverse().toString();
                    return s.equals(reversed);
                })
                .max(Comparator.comparingInt(String::length));

        return longestPalindrome.orElse("");
    }

    public static String capitalizeFrase(String string) {
        validarEntrada(string);

        return Arrays.stream(string.toLowerCase().split("(?<=\\.\\s)|(?<=\\?\\s)|(?<=\\!\\s)|(?<=\\:\\s)"))
                .map(sentence -> sentence.isEmpty() ? sentence : Character.toUpperCase(sentence.charAt(0)) + sentence.substring(1))
                .collect(Collectors.joining());
    }

    public static String anagramaPalindrome(String string) {
        validarEntrada(string);

        Map<Character, Long> charFrequencyMap = string.chars()
                .mapToObj(c -> (char) c)
                .collect(Collectors.toMap(Function.identity(), c -> 1L, Long::sum));

        long oddCount = charFrequencyMap.values()
                .stream()
                .filter(count -> count % 2 != 0)
                .count();

        return oddCount <= 1 ? "true" : "false";
    }
}