public class Criterios{

	//Se movimenta em 4 direções(cima,baixo,esquerda,direita). 
	//Referencia, ou seja por onde tá passando.
	private Game game; 
	private Posicao posInicial; 
	private Posicao posFinal; 
	private MovimentoExplorador movimento; 
	private int direcoes;
	Solucao solucao = null;
	double tempoExato = 0; 
	double tempoExato1 = 0;
	int peso;

	//	Calcula o tempo gasto com base no peso 
	public double calculaTempo(int peso){
		double t;
		t = (1 + (peso/10));
		t = Math.pow(t,2);
		return t;
	}

  public boolean Fim() { 
		return direcoes < 4; 
	}

	public void zerarDirecoes() { 
	 this.direcoes = 0; 
	}


	//Para usar na classe game.
	public Posicao getPosicao() { 
		return this.posInicial; 
	}
/*
	public void setPosicao(Posicao posicao) { 
		this.posInicial = posicao;
	}

	
	public void setPosicao(Posicao posicao) { 
	this.posFinal = posicao;
	}*/
  
	//Começar a se movimentar no ambiente. 
	public Posicao movimentar() { 
     int PosX = this.posInicial.getPosX();
	 int PosY = this.posInicial.getPosY();
		//Parar caso não de as 4 direções.
		if(this.direcoes >= 4){};
    
		
		Posicao retornarMovimento = retornarMovimento(); 
		
		//saber o local que ele está.
		String valor = this.game.retornarValorPosicaoLabirinto(retornarMovimento);
		
		//Caso o valor retornado seja o do próprio explorador ou a passagem esteja bloqueada não faça nada ou entrou um item. 
		if(valor.equals("X") || valor.equals("C")) {
			proximoMovimento();
			aumentarDirecoes();
			//Se não de certo tente novamente.
			movimentar(); 
			
		} else { 
      //Marca o caminho que foi passado.
			this.game.Caminhar(); 
			this.posInicial = retornarMovimento; 
		}
    return new Posicao(PosX,PosY);
	}

	private void aumentarDirecoes() { 
		this.direcoes += 1;
	}

	private void proximoMovimento() { 
		switch(this.movimento) { 
			case CIMA:
			this.movimento = MovimentoExplorador.BAIXO; 
			break;
			case BAIXO:
			this.movimento = MovimentoExplorador.ESQUERDA; 
			break;
			case ESQUERDA:
			this.movimento = MovimentoExplorador.DIREITA; 
			break;
			case DIREITA:
			this.movimento = MovimentoExplorador.CIMA; 
			break;
		}
}

	//Em um algoritmo de tentativa e erro, sempre tem a possibilidade de retornar o movimento que não dá certo.
	public Posicao retornarMovimento() { 

		int retornoPosX = this.posInicial.getPosX();
		int retornoPosY = this.posInicial.getPosY();
		//Caso o explorador for para cima, para retornar uma posição ele precisa ser maior que 0. 
		switch(movimento) { 
			case CIMA:
					if(retornoPosX > 0) { 
					retornoPosX -= 1; 
				}
					break; 

			case BAIXO: 
					if(retornoPosX < this.game.getLines() -1){
						retornoPosX +=1; 
					}
					break; 
					
				case ESQUERDA: 
					if(retornoPosY > 0) { 
					retornoPosY -= 1;
				}
					break; 
				
				case DIREITA:
					if(retornoPosY < this.game.getColumn() -1){ 
					retornoPosY += 1; 
				}
					break;
		}
		return new Posicao(retornoPosX, retornoPosY); 
} 

public Solucao play(Posicao posicaoInicial, Posicao posicaoFinal, int criterio){

		this.movimentar();

		switch(criterio){
			case 1: 
				this.criterio1(posicaoInicial,posicaoFinal);
				break;
			case 2:
				this.criterio2();
				break;
			case 3:
				this.criterio3();
				break;
			case 4:
				this.criterio4();
				break;
			default:
				System.out.println("Codigo do simulador invalido! Digite 1, 2, 3 ou 4.");
		}

		Solucao solucao = new Solucao();

		return solucao;

	}


public Solucao criterio1(Posicao posicaoInicial,Posicao posicaoFinal){

if(posicaoInicial.getPosX() == posicaoFinal.getPosX() && posicaoInicial.getPosY() == posicaoFinal.getPosY()) return new Solucao();
Solucao melhor = null; 

while(Fim()) { 
movimentar();
tempoExato += calculaTempo(peso);
melhor.adiciona(movimentar());
zerarDirecoes(); 

if(posicaoInicial.getPosX() != posicaoFinal.getPosX() && posicaoInicial.getPosY() != posicaoFinal.getPosY()) { 
aumentarDirecoes(); 
movimentar();
tempoExato1 += calculaTempo(peso);
solucao.adiciona(movimentar());
solucao = criterio1(posicaoInicial,posicaoFinal); 
if(solucao != null && melhor == null || solucao.tamanho() < melhor.tamanho()){
   melhor = solucao;
}else if(melhor != null) return melhor; 
}
        }
return melhor;
                }

                       



public Solucao criterio2(){
		System.out.println("\n Calculando CRITERIO 2");
		return null;
	}



	
public Solucao criterio3(){
		System.out.println("\n Calculando CRITERIO 3");
		return null;
	}



	
public Solucao criterio4(){
		System.out.println("\n Calculando CRITERIO 4");
		return null;
	}

}