classe Util

package lp2g16.biblioteca;

import excep.CodigoInvalidoEx;

import java.io.Serializable;
import java.util.*;

public class Util implements Serializable {

    public Util() {
    }

    public static Comparator<Livro> livroC = (p1, p2) -> {
        int pf1, pf2;
        pf2 = p2.getCodigo();
        pf1 = p1.getCodigo();
        return pf1 - pf2;
    };

    public static Comparator<Usuario> usuarioC = (p1, p2) -> {
        String pf1, pf2;
        pf2 = ValidaCPF.imprimeCPF(Long.toString(p2.getNumCPF()));
        pf1 = ValidaCPF.imprimeCPF(Long.toString(p1.getNumCPF()));
        return pf1.compareTo(pf2);
    };

    public static ArrayList<String> geraListaLivrosOrdenada(ArrayList<Livro> list) {
        list.sort(livroC);

        ArrayList<String> listaSimplificada = new ArrayList<>();
        for (Livro livro : list) {
            listaSimplificada.add(livro.getTitulo() + " , " + livro.getAutor()
                    + "\nCód: " + livro.getCodigo()
                    + "\nQtd de copias: " + livro.getQtdCopias() + "\n");
        }
        return listaSimplificada;
    }

    public static ArrayList<String> geraListaUsuariosOrdenada(ArrayList<Usuario> list) {
        list.sort(usuarioC);
        ArrayList<String> listaSimplificada = new ArrayList<>();
        for (Usuario user : list) {
            listaSimplificada.add(user.getNome() + " " + user.getSobrenome()
                    + " - CPF: " + ValidaCPF.imprimeCPF(Long.toString(user.getNumCPF()))
                    + " - Endereço: " + user.getEndereco()
                    + "\n");
        }
        return listaSimplificada;
    }

    static String formataDatas(GregorianCalendar data) {
        return data.get(Calendar.DAY_OF_MONTH) +
                "/" + (data.get(Calendar.MONTH) + 1) +
                "/" + data.get(Calendar.YEAR);
    }

    public static String leString(String msg, String regex) {
        boolean strLida = false;
        Scanner scan = new Scanner(System.in);
        String leitura = null;
        while (!strLida) {
            System.out.println(msg);
            leitura = scan.nextLine();
            if (!leitura.isEmpty() && leitura.matches(regex)) {
                strLida = true;
            }
        }
        return leitura;
    }

    public static int leCodigoLivro() throws CodigoInvalidoEx {
        boolean codLido = false;
        Scanner scan = new Scanner(System.in);
        String leitura = null;
        while (!codLido) {
            System.out.println("\nO codigo do livro tem 3 digitos, e vai de 1 a 999: ");
            leitura = scan.nextLine();
            if (ValidaOutrosParam.isCodigo(leitura)) {
                codLido = true;
            }
        }
        return Integer.parseInt(leitura);
    }

    public static String leNomeArquivo() {
        Scanner scan = new Scanner(System.in);
        String leitura;

        while (true) {
            System.out.println("Qual eh o nome do seu arquivo salvo? ");
            leitura = scan.nextLine();
            if (!leitura.isEmpty()) {
                return leitura;
            }
        }
    }

    public static int leQtd(String msg) throws IllegalArgumentException {
        boolean qtdLida = false;
        Scanner scan = new Scanner(System.in);
        String leitura;
        int qtd = 0;
        while (!qtdLida) {
            System.out.println(msg);
            leitura = scan.nextLine();
            try {
                qtd = Integer.parseInt(leitura);
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException();
            }
            if (qtd > 0 && qtd < 100) {
                qtdLida = true;
            } else {
                System.out.println("A quantidade minima eh 0, e a maxima, 100.");
            }
        }
        return qtd;
    }

    public static String leCPF_Usuario() throws IllegalArgumentException {
        boolean CPFLido = false;
        Scanner scan = new Scanner(System.in);
        String leitura = null;
        while (!CPFLido) {
            System.out.println("\nCPF precisa ser valido, e estar em um dos seguintes formatos: ");
            System.out.println("12345678901 ou 123.456.789-01 ou 123.456.789/01");
            System.out.print("Forneça o CPF:  ");
            leitura = scan.nextLine();
            if (ValidaCPF.isCPF(leitura)) {
                CPFLido = true;
            }
        }
        return leitura;
    }

    // funciona
    public static Livro.Categorias leCategoria(String msg) throws IllegalArgumentException {
        boolean catLida = false;
        Scanner scan = new Scanner(System.in);
        String leitura = null;
        while (!catLida) {
            System.out.println(msg);
            leitura = scan.nextLine();
            if (!leitura.isEmpty() && Livro.isCategoria(leitura.toUpperCase())) {
                catLida = true;
            } else {
                System.out.println("\nCategoria invalida! Escolha corretamente da lista de categorias:\n "
                        + Arrays.toString(Livro.Categorias.values()));
            }
        }
        return Livro.Categorias.valueOf(leitura);
    }

    protected static String leDia() throws IllegalArgumentException {
        boolean diaLido = false;
        Scanner scan = new Scanner(System.in);
        String leitura = null;
        while (!diaLido) {
            System.out.println("\nDia deve ter um valor entre 1 e 31");
            System.out.print("Informe o dia:  ");
            leitura = scan.nextLine();
            if (ValidaData.isDia(leitura)) {
                diaLido = true;
            }
        }
        return leitura;
    }

    protected static String leMes() throws IllegalArgumentException {
        boolean mesLido = false;
        Scanner scan = new Scanner(System.in);
        String leitura = null;

        while (!mesLido) {
            System.out.println("\nMes deve ter um valor entre 1 e 12, ou ser escrito corretamente por extenso");
            System.out.print("Informe o mes:  ");
            leitura = scan.nextLine();
            if (ValidaData.isMes(leitura)) {
                mesLido = true;
            }
        }
        return leitura;
    }

    protected static String leAno() throws IllegalArgumentException {
        boolean anoLido = false;
        Scanner scan = new Scanner(System.in);
        Calendar cal = new GregorianCalendar();
        String leitura = null;
        while (!anoLido) {
            int anoCorrente = cal.get(Calendar.YEAR);
            System.out.println("\nAno deve estar entre o ano corrente e " + (anoCorrente - 120));
            System.out.print("Informe o ano:  ");
            leitura = scan.nextLine();
            if (ValidaData.isAno(leitura)) {
                anoLido = true;
            }
        }
        return leitura;
    }

    public static GregorianCalendar leDatas() {

        String[] datas = new String[3];

        try {
            datas[0] = leDia();
        } catch (Exception e) {
            System.out.println("Erro ao ler o dia" + e.getMessage());
        }

        try {
            datas[1] = leMes();
        } catch (Exception e) {
            System.out.println("Erro ao ler o mes: " + e.getMessage());
        }

        try {
            datas[2] = leAno();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        try {
            if ((!datas[1].matches("^[0-9]{1,2}$")
                    || !ValidaData.isDataValida(Integer.parseInt(datas[0]), Integer.parseInt(datas[1]),
                    Integer.parseInt(datas[2]))) && !ValidaData.isDataValida(Integer.parseInt(datas[0]), datas[1],
                    Integer.parseInt(datas[2]))) {
                System.out.println("A data informada nao existe. Por favor tente de novo");
                leDatas();
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }

        return new GregorianCalendar(Integer.parseInt(datas[0]),
                Integer.parseInt(datas[1]), Integer.parseInt(datas[2]));
    }

}