package tps.tp2.pack3Coleccoes;

import java.util.Arrays;




import tps.tp2.pack2Livros.Livro;  // estaremos a trabalhar com a classe Livro do pack2Livros

/**
 * Classe Coleccao, deve conter a descrição de uma colecção, com título, os seus
 * livros, colecções e editores
 */
public class Coleccao {
    // número máximo de obras de uma colecção
    private static int MAXOBRAS = 20;

    // prefixo usual
    public static final String GENERALPREFIX = "  ";

    // título da colecção
    private String titulo;

    // Array de livros, em que estas encontram-se sempre nos menores índices e
    // pela ordem de registo
    private Livro[] livros = new Livro[MAXOBRAS];

    // deverá conter sempre o número de livros na colecção
    private int numLivros = 0;

    // array de colecções, estas devem ocupar sempre os menores índices
    private Coleccao[] coleccoes = new Coleccao[MAXOBRAS];

    // deverá conter sempre o número de colecções dentro da colecção
    private int numColeccoes = 0;

    // Editores, tem as mesmas condicionantes que array de autores na classe
    // livro
    private String[] editores;

    /**
     * Construtor; o título tem de ter pelo menos um caracter que não seja um
     * espaço (Character.isWhitespace); o array de editores devem ser pelo menos
     * um e têm as mesmas restrições que os autores dos livros;
     */
    public Coleccao(String titulo, String[] editores) {
        // titulo
        if (titulo == null || titulo.length() == 0)
            throw new IllegalArgumentException(
                    "O titulo tem de ter pelo menos um caracter");
        this.titulo = titulo;

        // ALTERADO: Validar o numero de editores fora do for, porque não vale a pena verificar isto tantas vezes quantos
        // editores existem.
        if( editores.length == 0 )
            throw new IllegalArgumentException("Os autores deve conter pelo menos um autor válido ");

        // FEITO
        for (int i = 0; i < editores.length; i++) {
            if(editores[i] == null ){
                throw new IllegalArgumentException("Os autores não deve conter nulls");
            }
        }
        this.editores = editores;
    }

    /**
     *
     */
    public String getTitulo() {
        // FEITO
        return this.titulo;
    }

    /**
     * Obtem o número total de páginas da colecção, páginas dos livros e das
     * colecções
     */
    public int getNumPaginas() {
        // FEITO
        int numPaginas=0;

        for (int i = 0; i < numLivros; i++) {
            numPaginas += livros[i].getNumPaginas();
        }

        for (int i = 0; i < numColeccoes; i++) {
            numPaginas += coleccoes[i].getNumPaginas();
        }

        return numPaginas;
    }

    /**
     * As colecções com mais de 5000 páginas nos seus livros directos têm um
     * desconto de 20% nesses livros. As colecções em que o somatório de páginas
     * das suas subcolecções directas seja igual ou superior ao quádruplo do nº
     * de páginas da sua subcolecção directa com mais páginas deverão aplicar um
     * desconto de 10% sobre os preços das suas subcolecções
     */
    public float getPreco() {
        // FEITO. MOSTRAR VANESSA
        float precoLivros = 0;

        int numPaginasDosLivros = 0;
        // Primeiro obtem-se o preço do numero de livros
        for( int i = 0; i < numLivros; i++ ) {
            numPaginasDosLivros += livros[i].getNumPaginas();
            precoLivros += livros[i].getPreco();
        }

        // Se a soma de páginas dos livros (apenas) for mais de 5000, aplica 20% de desconto sobre esses livros
        if ( numPaginasDosLivros > 5000 ) {
            float desconto = precoLivros * 0.2f;
            precoLivros = precoLivros - desconto;
        }

        // Depois obtem-se e calcula-se o preço das coleções
        float precoColecoes = 0;
        int maxNumPaginasColecao = 0; // valor do número de páginas da coleção directa com mais páginas
        int totalNumPaginasColecao = 0;
        for (int i = 0; i < numColeccoes; i++) {
            int numPaginasSubColecao = coleccoes[i].getNumPaginas();
            precoColecoes += coleccoes[i].getPreco();
            totalNumPaginasColecao += numPaginasSubColecao;

            // Actualiza o valor máximo de páginas encontrado, caso o numero seja maior até ao momento seja excedido
            if( numPaginasSubColecao > maxNumPaginasColecao ) {
                maxNumPaginasColecao = numPaginasDosLivros;
            }
        }

        if( totalNumPaginasColecao >= 4 * maxNumPaginasColecao ) {
            float desconto = precoColecoes * 0.1f;
            precoColecoes = precoColecoes - desconto;
        }

        return precoLivros + precoColecoes;
    }

    /**
     * Adiciona um livro à colecção se puder e este não seja null e a colecção
     * não ficar com livros iguais ao nível imediato da colecção. Deve utilzar o
     * método getIndexOfLivro e getIndexOfColeccao
     */
    public boolean addLivro(Livro livro) {
        // FEITO

        if (livro != null && getIndexOfLivro(livro.getTitulo())== -1 && getIndexOfColeccao(livro.getTitulo())== -1){
            livros[numLivros++] = livro;

            return true;
        }
        return false;
    }

    /**
     *
     * Adiciona uma colecção à colecção se puder, esta não seja null e a
     * colecção não ficar com obras imediatas com títulos repetidos. Deve
     * utilizar o método getIndexOfLivro e getIndexOfColeccao
     */
    public boolean addColeccao(Coleccao col) {
        // FEITO

        if (col != null && getIndexOfLivro(col.getTitulo())== -1 && getIndexOfColeccao(col.getTitulo())== -1){
            coleccoes[numColeccoes++] = col;

            return true;
        }
        return false;
    }

    /**
     * Devolve o index no array de livros onde estiver o livro com o nome
     * pretendido. Devolve -1 caso não o encontre
     */
    private int getIndexOfLivro(String titulo) {
        // FEITO

        for (int i = 0; i < numLivros; i++) {
            if(livros[i] != null && livros[i].getTitulo().equals(titulo)){
                return i;
            }
        }
        return -1;
    }

    /**
     * Devolve o index no array de colecções onde estiver a colecção com o nome
     * pretendido. Devolve -1 caso não o encontre
     */
    private int getIndexOfColeccao(String titulo) {
        // FEITO
        for (int i = 0; i < numColeccoes; i++) {
            if(coleccoes[i] != null && coleccoes[i].getTitulo().equals(titulo)){
                return i;
            }
        }
        return -1;
    }

    /**
     * Remove do array o livro com o título igual ao título recebido. Devolve o
     * livro removido ou null caso não tenha encontrado o livro. Deve-se
     * utilizar o método getIndexOfLivro. Recorda-se que os livros devem ocupar
     * sempre os menores índices, ou seja, não pode haver nulls entre os livros
     */
    public Livro remLivro(String titulo) {
        // FEITO
        Livro livroRemovido = null;

        if(getIndexOfLivro(titulo) == -1)
            return null;

        for (int i = 0; i < numLivros; i++) {
            livroRemovido = livros[i];
            livros[i] = null;
            numLivros--;
        }

        Livro livrosNovos [] = new Livro[livros.length];
        int indexLivrosNovos=0;

        for (int i = 0; i < livrosNovos.length; i++) {
            if(livros[i]!= null){
                livrosNovos[indexLivrosNovos++]= livros[i];
            }
        }
        this.livros = livrosNovos;

        return livroRemovido;


    }

    /**
     * Remove do array de colecções a colecção com o título igual ao título
     * recebido. Devolve a colecção removida ou null caso não tenha encontrado.
     * Deve-se utilizar o método getIndexOfColeccao. Recorda-se que as colecções
     * devem ocupar sempre os menores índices, ou seja, não pode haver nulls
     * entre elas
     */
    public Coleccao remColeccao(String titulo) {
        // FEITO
        Coleccao colecaoRemovida = null;

        if( getIndexOfColeccao(titulo)==-1 ) {
            return null;
        }
        for (int i = 0; i < numColeccoes; i++) {
            colecaoRemovida = coleccoes[i];
            coleccoes[i] = null;
            numColeccoes--;
        }
        Coleccao novasColecoes [] = new Coleccao[coleccoes.length];
        int indexColecoesNovas = 0;
        for (int i = 0; i < novasColecoes.length; i++) {
            if(coleccoes[i] != null) {
                novasColecoes[indexColecoesNovas++] = coleccoes[i];
            }
        }
        this.coleccoes = novasColecoes;

        return colecaoRemovida;
    }

    /**
     * Devolve o nº de obras de uma pessoa. Cada colecção deve contabilizar-se
     * como uma obra para os editores.
     */
    public int getNumObrasFromPerson(String autorEditor) {
        // FEITO. ALTERADO MOSTRAR VANESSA
        int numObras =0;

        // conta o numero de livros em que o autor está presente (ALTERADO)
        for (int i = 0; i < numLivros; i++) {
            if(livros[i].contemAutor(autorEditor)){
                    numObras++;
            }
        }

        // ver se o autor está presente na coleção actual
        for( int i = 0; i < editores.length; i++) {
            if( editores[i].equals(autorEditor) ) {
                numObras++;
                break;
            }
        }

        // conta o número de obras que o autor tem nas colecções
        for (int i = 0; i < numColeccoes; i++) {
            // ver quantos livros o autor tem na colecao
            numObras += coleccoes[i].getNumObrasFromPerson(autorEditor);
        }

        return numObras;
    }

    /**
     * Devolver um novo array (sem nulls) com os livros de que a pessoa recebida
     * é autor. Não deve conter repetições, para excluir as repetições devem
     * utilizar o método mergeWithoutRepetitions
     */
    public Livro[] getLivrosComoAutor(String autorNome) {

        //FEITO
        Livro[] livrosAutoresComNull = new Livro[numLivros];
        int numLivrosAutor = 0;

        // percorrer a lista de livros
        for (int i = 0; i < numLivros; i++) {
            if(livros[i].contemAutor(autorNome)){ // se o livro contiver o autor, adicionamos a lista
                livrosAutoresComNull[numLivrosAutor] = livros[i];
                numLivrosAutor++;
            }
        }

        // retirar os nulos da lista
        Livro[] livrosAutores= new Livro[ numLivrosAutor ];
        for(int i = 0; i < livrosAutores.length; i++ ) {
            livrosAutores[i] = livrosAutoresComNull[i];
        }

        // obter agora os livros das coleccoes (adicionado)
        for(int i = 0; i < numColeccoes; i++) {
            livrosAutores = mergeWithoutRepetitions(livrosAutores, coleccoes[i].getLivrosComoAutor(autorNome));
        }

        return livrosAutores;

    }

    /**
     * Deve devolver uma string compatível com os outputs desejados
     */
    public String toString() {
        // FEITO - Explicar
        String resultado = new String();

        resultado = "Coleção " + this.titulo + ", editores" + Arrays.toString(this.editores) + ", " + this.numLivros + " livros, "
                        + this.getNumPaginas() + "p " + this.getPreco() + "€";

        return resultado;
    }
    /**
     * Deve devolver um array, sem nulls, com todos os autores e editores
     * existentes na colecção. O resultado não deve conter repetições. Deve
     * utilizar o método mergeWithoutRepetitions
     */
    public String[] getAutoresEditores() {

        // FEITO
        String[] arraySemRep = this.editores;
        for (int i = 0; i < numLivros; i++) {
            arraySemRep = mergeWithoutRepetitions(arraySemRep, this.livros[i].getAutores());
        }

        // Adicionar os autores/editores das colecoes (ALTERADO/FALTAVA)
        for( int i = 0; i < numColeccoes; i++ ) {
            arraySemRep = mergeWithoutRepetitions(arraySemRep, this.coleccoes[i].getAutoresEditores() );
        }

        return arraySemRep;

    }

    /**
     * Método que recebendo dois arrays sem repetições devolve um novo array com
     * todos os elementos dos arrays recebidos mas sem repetições
     */
    private static String[] mergeWithoutRepetitions(String[] a1, String[] a2) {
        //FEITO

        int index = 0;
        int contarRepetidos = 0;
        String novoArrayComNulls[] = new String[a1.length+a2.length];

        for (int i = 0; i < a1.length; i++) { //adiciona os elementos do array 1 ao novo array que está vazio
            novoArrayComNulls[index++] = a1[i];
        }

        // adiciona os elementos do array 2 se no novo array esse elemento ainda não existir
        for (int i = 0; i < a2.length; i++) {
            boolean existe = false; // variavel para controlar se o elemento existe no novo array

            for( int j = 0; j < novoArrayComNulls.length; j++ ) { // percorrer o novo array à procura do elemento actual
                if( a2[i].equals(novoArrayComNulls[j]) ) { // o elemento existe, portanto assinalamos e saimos do ciclo
                    existe = true;
                    break;
                }
            }

            // depois de percorrer o array todo, sabemos que o nº não existe, por isso vamos adiciona-lo
            if( existe == false ) {
                novoArrayComNulls[index++] = a2[i];
            } else { // já existe, portanto temos que incrementar o contador de repetidos
                contarRepetidos++;
            }

        }

        // temos que remover os nulls do novoArrayComNulls
        String[] novoArray = new String[ novoArrayComNulls.length - contarRepetidos ];
        // copiar o array com nulos para o novo array sem posições nulas
        for( int i = 0; i < novoArray.length; i++) {
            novoArray[i] = novoArrayComNulls[i];
        }

        return novoArray;

    }

    /**
     * Método idêntico ao método anterior mas agora com arrays de livros
     */
    private static Livro[] mergeWithoutRepetitions(Livro[] a1, Livro[] a2) {
        // FEITO

        int index = 0;
        int contarRepetidos = 0;
        Livro arrayLivrosComNulls[] = new Livro[a1.length+a2.length];

        for (int i = 0; i < a1.length; i++) { //adiciona os elementos do array 1 ao novo array que está vazio
            arrayLivrosComNulls[index++] = a1[i];
        }

        // adiciona os elementos do array 2 se no novo array esse elemento ainda não existir
        for (int i = 0; i < a2.length; i++) {
            boolean existe = false; // variavel para controlar se o elemento existe no novo array

            for( int j = 0; j < arrayLivrosComNulls.length; j++ ) { // percorrer o novo array à procura do elemento actual
                if( a2[i].equals(arrayLivrosComNulls[j]) ) { // o elemento existe, portanto assinalamos e saimos do ciclo
                    existe = true;
                    break;
                }
            }

            // depois de percorrer o array todo, sabemos que o nº não existe, por isso vamos adiciona-lo
            if( existe == false ) {
                arrayLivrosComNulls[index++] = a2[i];
            } else { // já existe, portanto temos que incrementar o contador de repetidos
                contarRepetidos++;
            }

        }

        // temos que remover os nulls do arrayLivrosComNulls
        Livro[] arrayLivros = new Livro[ arrayLivrosComNulls.length - contarRepetidos ];
        // copiar o array com nulos para o novo array sem posições nulas
        for( int i = 0; i < arrayLivros.length; i++) {
            arrayLivros[i] = arrayLivrosComNulls[i];
        }

        return arrayLivros;

    }

    /**
     * Devolve true caso a colecção recebida tenha o mesmo título e a mesma
     * lista de editores. Para verificar se os editores são os mesmos
     * devem utilizar o método mergeWithoutRepetitions
     */
    public boolean equals(Coleccao c) {
        // FEITO. Alterado de 'editores' para 'getAutoresEditores()'

        if(!this.getTitulo().equals(c.getTitulo())) {
            return false;
        }

        if((mergeWithoutRepetitions(c.getAutoresEditores(),this.getAutoresEditores()).length == this.getAutoresEditores().length) && this.getAutoresEditores().length == c.getAutoresEditores().length) {
            return true;
        }
        return false;

    }

    /**
     * Mostra uma colecção segundo os outputs desejados
     */
    public void print(String prefix) {
        // FEITO
        System.out.println(prefix + this);
        // AQUI
        //Falta um for para imprimir as coleções

        //faltou este for para imprimir os livros existentes nas coleçoes
        for (int i = 0; i < numLivros; i++) {
            if(livros[i]== null)
                continue;

            livros[i].print("  " + prefix); // para imprimir em profundidade chama a funcao print do livro (alterado)

        }

        for (int i = 0; i < numColeccoes; i++) {
            if(coleccoes[i] ==null)
                continue;
            coleccoes[i].print("  " + prefix); // o mesmo para as coleções
        }

    }

    /**
     * main
     */
    public static void main(String[] args) {
        Livro l1 = new Livro("Viagem aos Himalaias", 340, 12.3f,
                new String[] { "João Mendonça", "Mário Andrade" });
        Livro l2 = new Livro("Viagem aos Pirinéus", 270, 11.5f,
                new String[] { "João Mendonça", "Júlio Pomar" });

        Coleccao c1 = new Coleccao("Primavera",
                new String[] { "João Mendonça", "Manuel Alfazema" });

        boolean res;

        res = c1.addLivro(l1);
        res = c1.addLivro(l2);
        System.out.println("c1 -> " + c1);
        c1.print("");
        System.out.println();

        // adicionar um livro com nome de outro já existente
        res = c1.addLivro(l2);
        System.out.println(
                "adição novamente de Viagem aos Pirinéus a c1 -> " + res);
        System.out.println("c1 -> " + c1);
        System.out.println();

        // Outra colecção
        Livro l21 = new Livro("Viagem aos Himalaias 2", 340, 12.3f,
                new String[] { "João Mendonça", "Mário Andrade" });
        Livro l22 = new Livro("Viagem aos Pirinéus 2", 270, 11.5f,
                new String[] { "João Mendonça", "Júlio Pomar" });

        Coleccao cx2 = new Coleccao("Outono",
                new String[] { "João Mendonça", "Manuel Antunes" });
        cx2.addLivro(l21);
        cx2.addLivro(l22);
        System.out.println("cx2 -> " + cx2);
        cx2.print("");
        System.out.println();

        // adicioná-la a c1
        c1.addColeccao(cx2);
        System.out.println("c1 após adição da colecção cx2 -> " + c1);
        c1.print("");
        System.out.println();

        // get editores autores
        String[] ae = c1.getAutoresEditores();
        System.out.println("Autores editores of c1 -> " + Arrays.toString(ae));
        System.out.println();

        // getNumObrasFromPerson
        String nome = "João Mendonça";
        int n = c1.getNumObrasFromPerson(nome);
        System.out.println("Nº de obras de " + nome + " -> " + n);
        System.out.println();

        // getLivrosComoAutor
        nome = "João Mendonça";
        Livro[] obras = c1.getLivrosComoAutor(nome);
        System.out
                .println("Livros de " + nome + " -> " + Arrays.toString(obras));
        System.out.println();

        // rem livro
        String nomeLivro = "Viagem aos Himalaias";
        Livro l = c1.remLivro(nomeLivro);
        System.out.println("Remoção de " + nomeLivro + " -> " + l);
        c1.print("");
        System.out.println();
    }
}