/*
 *Autor: Ary Andrade Neto
 *Objetivo:
 * Dado um numero n (aleatorio) o programa desenha n linhas (aleatorias)
 *computa as intesecoes, quantos polignos existem e informa quais sao os tipo
 *e colore cada um de uma cor diferente
 *desafio1.js puxado por index.html
 * Estutura de dados:
 *l = [[x0,y0],[vx,vy],[t1,t2,...,tn]]; //lista das retas
 *p = [[a,ta,b,tb],[a,ta,b,tb],...]
 *-lista dos pontos, onde a e b sao as retas que se cruzam e ta e tb o a "distancia" do ponto inicial (entre 0 e 1)
 *OBS:
	obs: terminar de implementar as funcoes
	e procurar se precisa de mais alguma
	ou se tem alguma redundante!

	Proximo passo limitar
	 a formla de intersecao estende uma linha imaginaria
	 falta limitar esse valor ate o tamaho maximo da linha (seus estremos)
	fazer umma condicao para criar esse limite

*/
//ver se precisa mesmo dessas variaveis
var j=0;
var cont=0, k=1, jponto=0;
var n;
var l=[], p=[];

function setup() {
	createCanvas(640, 480);
	//n = random(10);
	n = 3;
}

function draw() {
  var pontos=[];
	poligno();


    //linha pronta
	pontos=linhaPronta(j);
	j++;
/*
	linhaAleatoria();
*/
	// console.log(l);
	intersecLine(l);
/*
	if (cont<Math.trunc(n)){
		var x = intersecLine(l);
		console.log(x);
		stroke(0);
  		point(x[0], x[1]);
	}
	ponto(p);
	//console.log(x);
	//desenhar linhas aleatorias
*/
}
function intersecLine(lista){
	//dado uma lista (l) com as retas
	//adiciona os pontos de intersecao na lista p
	//adiciona os t nas listas e os ordena
	if (cont<Math.trunc(n)-1){
		var pontoR;
		pontoR = intersec(lista[cont], lista[k++]);
		if (pontoR != 0){
			p.push([cont, pontoR[0], k-1, pontoR[1]]);
			console.log(p);
			l[cont][2].push(pontoR[0]);
			l[k-1][2].push(pontoR[1]);
			insertionSort(l[cont][2],l[cont][2].length);
			insertionSort(l[k-1][2],l[k-1][2].length);
		}
	}else{
		return;
	}
	if(k>Math.trunc(n)-1){
		cont++;
		k=cont+1;
	}
	return;
}
function orientacao(x, y, z){
	var det;
	det = (y[0]*z[1])+(z[0]*x[1])+(x[0]*y[1])-(x[1]*y[0])-(y[1]*z[0])-(z[1]*x[0]);
	if (det>0){
		return 1;
	}else if(det<0){
		return -1;
	}else{
		return 0;
	}
}
function poligno(){
	var interna, contador, posicao, pontinho;
	interna = p[jponto];
	if (interna != null){
		contador = l[interna[0]][2];
		posicao = pesquisaBinaria(interna[1], contador, 0, contador.length);
		//console.log(contador.length, posicao);
		if(posicao+1<contador.length){
		//	console.log(contador, posicao, contador[posicao+1]);
			pontinho = buscarPonto(interna[0], l[interna[0]][2][posicao+1], 0);
		//	console.log("pontinho",pontinho);
		}else if(posicao-1>=0){
		//	console.log(contador, posicao, contador[posicao+1]);
			pontinho = buscarPonto(interna[0], l[interna[0]][2][posicao-1], 0);
			//console.log("pontinhoN",pontinho);
		}
	}


}
function colorir(lista){
	//pegar os pontos dessa lista e colorir todos por beginShape()
	var r,g,b;
	r = random(255);
	g = random(255);
	b = random(255);

}
function intersec(a, b){
	//dado duas lista (l)
	//tira o determinante, se ele for 0: nao cruza e retorna 0,
	// caso contrario, retorna lista com t da primeira reta e o da segunda
	//retorna 0 se alguma lista passada for null
 	/*problemaa a funcao retorna o ponto de intersecao entre duas linhas pequena como se elas se esedessem
	 limitar com mais testes para verificar se o ponto esta na reta (linha)
 	*/
 	var det;
 	if (a==null || b==null){
 		return 0;
 	}
	var ax0 = a[0][0];
	var ax1 = a[0][0] + a[1][0];
	var ay0 = a[0][1];
	var ay1 = a[0][1] +a[1][1];

	var bx0 = b[0][0];
	var bx1 = b[0][0] + b[1][0];
	var by0 = b[0][1];
	var by1 = b[0][1] + b[1][1];

	det = (bx1 - bx0) * (ay1 - ay0) - (by1 - by0) * (ax1 - ax0);

 	if (det == 0.0){
 		return 0; // não há intersecção
	}

 	var s, x, y;
	s = ((bx1 - bx0) * (by0 - ay0) - (by1 - by0) * (bx0 - ax0))/det;
	x = ax0 + (ax1 - ax0) * s;
	y = ay0 + (ay1 - ay0) * s;

	if (min(ax0,ax1)<= x && max(ax0,ax1) >= x && min(ay0,ay1)<= y && max(ay0,ay1) >= y){
		if (min(bx0,bx1)<= x && max(bx0,bx1) >= x && min(by0,by1)<= y && max(by0,by1) >= y){
			stroke(0);
			point(x,y);
			var ta, tb;
			ta = (x - ax0)/ a[1][0];
			tb = (x - bx0)/ b[1][0];
			console.log("ta = ",	ta, tb);
			return [ta, tb];
		}
	}
	return 0;
}
function linhaAleatoria(){
	//tralca uma linha aleatoria se o argumento dado for menor que n.
	//e retorna uma uma lista de lista com os 4 pontos aleatorios
	var v = [];
	if (j<Math.trunc(n)){
		r1 = random(640);
		r2 = random(400);
		r3 = random(640);
		r4 = random(400);
		stroke(200);

		v[0] = r3-r1;
		v[1] = r4-r2;

		l[j]=[[r1, r2], v, []];
		line(r1, r2, r3, r4);
		console.log("vai ", j, l[j]);
		j++;
		linhaAleatoria();
		return;
	}else{
		return;
	}
}
function linhaPronta(i){
	//3 linhas fixas
	if (i<1){
		var x0, x1, y0, y1;
		var li=[]
		stroke(200);
		line(x0=50, y0=300, x1=600, y1=300); //linha paralela esquerda - 1
		l[0]=[[x0,y0],[x1-x0,y1-y0],[]];
		line(x0=200, y0=50, x1=500, y1=400); //linha paralela direita - 3
		l[1]=[[x0,y0],[x1-x0,y1-y0],[]];
		line(x0=100, y0=400, x1=400, y1=50); //linha cruza direita - 4
		l[2]=[[x0,y0],[x1-x0,y1-y0],[]];
	}
}
function insertionSort(lista, n) {
	//ordena um lista de tamanho n em ordem crescente
	var aux, i, x;
	for (i=1; i<n; i++){
		aux = lista[i];
		x = i-1;
		while (x>=0 && lista[x]>aux){
			lista[x+1] = lista[x];
			x--;
		}
		lista[x+1] = aux;
	}
}// x => chave | v[] => vetor ordenado | e => Limite inferior (esquerda) | d => Limite Superior (direita)
function pesquisaBinaria(x, v, e, d){
 var i = Math.trunc((e + d)/2);
 console.log();
 if (v[i] == x)
    return i;
 if (e >= d)
    return -1; // Não foi encontrado
 else
     if (v[i] < x)
        return pesquisaBinaria(x, v, i+1, d);
     else
        return pesquisaBinaria(x, v, e, i-1);
}
function buscarPonto(reta, t, contador){
	if ((p[contador][0] == reta && p[contador][1] == t) || (p[contador][2] == reta && p[contador][3] == t)){
		return contador;
	}else{
		buscarPonto(reta, t, contador+1);
	}
}