package pds01;

import java.util.List;

/**
 * Esta classe simula uma Sopa de Letras. Permite-nos receber uma grelha de jogo
 * e resolvê-la
 * @author grupo22
 *
 */
public class SopaLetras {
    private char[][] grelha; //guarda a grelha de jogo
    private int linha; //serve como uma das coordenadas do ponto de partida da pesquisa
    private int col; // serve como uma das coordenadas do ponto de partida
    private int pesquisa_linha; //coordenada que será utilizada durante a procura da palavra
    private int pesquisa_col; //coordenada que será utilizada durante a procura da palavra
    private List<String> palavras; //palavras a serem procuradas
    /**
     * Constrói uma Sopa de Letras com a grelha especificada e a lista de palavras a procurar
     * @param grelha grelha de letras usada para jogar
     * @param palavras Lista de palavras a serem procuradas na sopa de letras
     */
    public SopaLetras(char[][] grelha, List<String> palavras){
    	this.palavras = palavras;
        this.grelha=grelha;
        this.linha=0;
        this.col=0;
    }

    public void solver() {
    	palavras.forEach(e -> procurar(e));
    }

    public void solverCronometrado() {
    	long startTime = System.nanoTime();
    	solver();
    	long endTime = System.nanoTime();

    	double duration = (endTime - startTime)/1000000000.0;
    	System.out.printf("Elapsed time (secs): %6.4f\n", duration);
    }

    /**
     * Este método procura, na grelha de jogo, uma letra
     * correspondente à primeira letra da palavra
     * para que se possa efetuar a procura da palavra. O método
     * irá atualizar a linha e coluna onde o caracter se encontra
     * para servir de ponto de partida
     * @param word Palavra a ser procurada
     * @return true se o primeiro caracter da palavra estiver na grelha;
     * false, caso contrário
     */
    private boolean primeiraLetra(String word){
    	//percorrer grelha até encontrar uma letra que corresponde à primeira letra da palavra especificada
        for(int i=linha;i<grelha.length;i++){
            for(int j=col;j<grelha[i].length;j++){
                if(word.charAt(0)==grelha[i][j]){
                	//atualizar coordenadas quando encontrada a letra pretendida
                    linha = i;
                    col = j;
                    pesquisa_linha=i;
                    pesquisa_col=j;
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Este método usa os valores da coluna e linha de procura atualizados
     * pelo método primeiraLetra como ponto de partida. A partir dessas coordenadas,
     * irá procurar a palavra especificada na direção especificada
     * @param word Palavra a ser procurada
     * @param tipe Direção para a qual a palavra será procurada na grelha
     * @return true se a palavra for encontrada; false, caso contrário
     */
    public boolean procurar_palavra(String word, Direction tipe){
        String temp="";
        int c=0;
        while(pesquisa_linha>=0 && pesquisa_col>=0 && pesquisa_linha<grelha.length && pesquisa_col<grelha.length && c<word.length()){
            //contruir palavra temporária para avaliação posterior
        	temp+=grelha[pesquisa_linha][pesquisa_col];
            direction(tipe);
            c++;

        }

        //se a palavra temporária corresponder à palavra especificada, retornar true
        if(word.equalsIgnoreCase(temp)){
            return true;
        }
        return false;
    }

    /**
     * Este método traduz a direção recebida para a forma como a grelha de jogo
     * será percorrida. Ou seja, irá atualizar a linha e/ou coluna de pesquisa
     * consoante a direção recebida
     * @param tipe Direção pela qual se percorrerá a grelha
     */
    public void direction(Direction tipe){
        switch(tipe){
            case left:
                pesquisa_col--;
                break;
            case downleft:
                pesquisa_col--;
                pesquisa_linha++;
                break;
            case upleft:
                pesquisa_col--;
                pesquisa_linha--;
                break;
            case right:
                pesquisa_col++;
                break;
            case upright:
                pesquisa_col++;
                pesquisa_linha--;
                break;
            case downright:
                pesquisa_col++;
                pesquisa_linha++;
                break;
            case down:
                pesquisa_linha++;
                break;
            case up:
                pesquisa_linha--;
                break;
        }

    }

    /**
     * Este método irá fazer uso dos métodos primeiraLetra() e avaliar()
     * para procurar a palavra especificada.
     * @param word Palavra a ser procurada
     */
    public void procurar(String word){
    	//flag servirá para verificar se a palavra foi encontrada ou não
        boolean flag = false;
        while(!flag){
            primeiraLetra(word); //procurar primeira letra da palavra na grelha

            /*
             * usar as coordenadas determinadas anteriormente como ponto de partida
             * para procurar a palavra em todas as direções
             */
            flag = avaliar(word,Direction.left) || avaliar(word,Direction.downleft) || avaliar(word,Direction.upleft) || avaliar(word,Direction.right) || avaliar(word,Direction.downright) || avaliar(word,Direction.upright) || avaliar(word,Direction.up) || avaliar(word,Direction.down);
            //sair do ponto de partida anterior para continuar a procura
            if(col<grelha.length){
                col++;
            }else if(linha<grelha.length){
                linha++;
                col=0;
            }else{
                System.out.println("Não encontrou");
                break;
            }
        }

    }

    /**
     * Este método irá imprimir a palavra e os resultados da sua procura,
     * caso a palavra seja encontrada.
     * @param word Palavra a ser procurada
     * @param tipe Direção pela qual a grelha é percorrida
     * @return true se a palavra for encontrada; false, caso contrário
     */
    public boolean avaliar(String word, Direction tipe){
        if(procurar_palavra(word,tipe)){
            System.out.printf("%-10s%-5d%d,%d%10s\n",word.toUpperCase(),word.length(),linha,col,tipe);
            linha = 0;
            col = 0;
            return true;
        }else{
        	//se palavra não for encontrada, voltar ao ponto de partida para procurar noutra direção
            pesquisa_linha = linha;
            pesquisa_col = col;
            return false;
        }
    }

}