import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.ArrayList;

public class Ligne extends ObjetGraphique{// Hérite de la classe ObjetGraphique
	// Ne pas oublier qu'il y a des propriétés et méthodes reçues par l'héritage

	//-------------------------------------------------------------------------
	// PROPRIETES  
	//-------------------------------------------------------------------------	

	// nb de Segments qui composent la ligne
	protected int nbSegments = 400;

	// position du cercle, pour déterminer quel est le segment courant
	protected double xCercle = 400; // à modifier
	
	// segment qui se trouve au niveau du cercle : on le mémorise pour accélérer les traitements 
	protected Segment SegCourant;
	
	// Propriété listes de segements: Une ligne est constitué de plusieurs segments. 
	// Stockage des segments afin de pouvoir les afficher et les animer plus tard 
	protected ArrayList<Segment> listeSegments = new ArrayList<>();

	// propriété de la vitesse de base de déplace de la ligne
	protected int vitesseLigne = 5;
	
	// On définit les limites (plafond et sol)
	protected int plafond = 50; // Empêche de monter trop haut (Y=0 est le bord haut)
	protected int sol = 550; // Empêche de descendre trop bas (Y=600, est le bas)

	//-------------------------------------------------------------------------
	// METHODES
	//-------------------------------------------------------------------------
	
	//-------------------------------------------------------------------------
	// Constructeur de la classe
	//-------------------------------------------------------------------------	
	public Ligne(){

	}

	// Méthode pour (RE)générer la ligne 
	public void generer(int nbSegments, int difficulte){
		// On vide la ligne précédente
		this.listeSegments.clear();

		// Valeurs initiales pour la position de la Ligne
		double x = 800;
		double y = 200;
		double dx,dy;

		// Plus le niveau est grand plus dy peut-être grand (pics plus abrupts)
		double amplitude = 30 * difficulte;

		// On réduit la largeur des segments pour "serrer" les pics 
		// Plus dx est petit, plus les pics sont proches les uns des autres
		double largeurMin = 100 - (difficulte * 15);
		
		// Création de la liste de segments qui composent la ligne
		Segment s;
		for (int i=0; i<nbSegments; i++){

			// définition d'un nouveau segment
			dx = Math.random()*20 + largeurMin;
			dy = Math.random()*(amplitude*2) - amplitude;

			// Vérification plafond de l'écran
			if(y + dy < plafond){
				// On force le segment à s'arréter à 50
				dy = plafond - y;
			}

			// Vérification sol de l'écran
			if(y + dy > sol){
				// Si ça dépasse en bas, on force le segment à s'arrêter à 550
				dy = sol - y;
			}
			s = new Segment(x,y,dx,dy);
			s.setCouleur(new Color(0.2f,0.2f,0.2f));
			//Ajouter un segment dans la ligne
			this.listeSegments.add(s);
			x += dx;
			y += dy;
		}

		// On remet le segment courant à zéro afin de ne pas avoir un retard sur un cycle
		// Et repartir proprement
		this.SegCourant = null;
	}

	//Méthode set pour modifier la vitesse de déplacement la ligne
	public void setVitesseLigne(int new_vitesse){
		this.vitesseLigne = new_vitesse;
	}
	
	// ------------------------------------------------------------------------
	// Méthode pour réactualiser le segment courant
	// ------------------------------------------------------------------------
	public void actualiserSegCourant(){
		this.SegCourant = null;
		for(Segment s: this.listeSegments){
			if( (xCercle >= s.x) && ( xCercle <= (s.x + s.xLong) ) ){
					this.SegCourant = s;
					break;
			}
		}
	}

	//-------------------------------------------------------------------------	
	// Redéfinition de la méthode Afficher, spécifiquement pour la classe Ligne
	//-------------------------------------------------------------------------
	@Override
	public void Afficher(Graphics g){
		
		// On définit l'épaisseur du trait
		Graphics2D g2D = (Graphics2D) g;
		g2D.setStroke(new BasicStroke(3.0f));
		this.actualiserSegCourant();
		
		for(Segment s: this.listeSegments){
			s.Afficher(g);
		}
		
	}

	//-------------------------------------------------------------------------	
	// Redéfinition de la méthode Animer, spécifiquement pour la classe Ligne
	//-------------------------------------------------------------------------
	@Override
	public void Animer() {
		
		// Principe : 
		// on parcourt tous les segments et on décale chacun de 10 pixels (par exemple)
		// vers la gauche
		// On modifiera cette méthode en fonction du niveau de jeu
		for(Segment s: this.listeSegments){
			s.x -= this.vitesseLigne;
		}
		
	}

	//-------------------------------------------------------------------------
	// Méthode qui vérifie si la ligne est dans le cercle
	// Principe:
	// 1- On détermine la hauteur du point du segment qui se trouve au niveau du cercle
	// 2- On calcule la distane entre ce point et le centre du cercle
	// 3- On compare cette distance avec le rayon du cercle  
	//-------------------------------------------------------------------------
	public boolean estDansCercle(Cercle c){
		boolean dansCercle = false;
		if(this.SegCourant != null){
			// 1- On détermine la hauteur du point du segment qui se trouve au niveau du cercle
			// En utilisant la formule de Thales
			// Ce point se touve à la position xPoint = xCercle
			double yPoint = this.SegCourant.y + (this.SegCourant.yLong / this.SegCourant.xLong) * (this.xCercle - this.SegCourant.x);
			double xPoint = this.xCercle;

			// 2- On calcule la distance entre ce point et le centre du cercle
			double distance = Math.sqrt(Math.pow(xPoint - c.x, 2) + Math.pow(yPoint - c.y, 2));

			// 3- On compare cette distance avec le rayon du cercle
			if(distance <= c.rayon){
				this.SegCourant.setCouleur(Color.GREEN);
				dansCercle = true;
			}else{
				this.SegCourant.setCouleur(Color.RED);
				dansCercle = false;
				
			}
		}
		return dansCercle;
	}
	public Segment getSegCourant() {
        return this.SegCourant;
    }
}