package linea;

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 {

	protected int nbSegments = 80;
	protected Segment SegCourant;

	protected ArrayList<Segment> listeSegments = new ArrayList<Segment>();

	protected Segment dernierSegment;
	private double decalageXDernierSegment = 0;

	private NoiseGenerator noiseGenerator;
	private GestionnaireNiveau gestionnaireNiveau;

	private double xActuel;

	// Curseur dans le noise : avance plus vite quand la frequence du niveau augmente
	private double noiseCurseur = 0;

	public Ligne(NoiseGenerator noiseGenerator, GestionnaireNiveau gestionnaireNiveau) {
		double x = 0;

		this.noiseGenerator = noiseGenerator;
		this.gestionnaireNiveau = gestionnaireNiveau;

		double dx = GetLargeurSegment();
		double freq = gestionnaireNiveau.getNoiseFrequence();

		for (int i = 0; i < nbSegments; i++) {
			double noiseStep = dx * freq;
			double yDebut = CalculerY(noiseCurseur);
			double yFin = CalculerY(noiseCurseur + noiseStep);

			Segment s = new Segment(x, yDebut, dx, yFin - yDebut);
			s.setCouleur(new Color(0.2f, 0.2f, 0.2f));

			listeSegments.add(s);
			noiseCurseur += noiseStep;

			if (i == nbSegments - 1) {
				dernierSegment = s;
				xActuel = x + dx;
			}

			x += dx;
		}
	}

	protected double GetLargeurSegment(){
		return (double)ZoneDessin.largeur / nbSegments;
	}

	protected Segment CreerSegmentSuivant(){
		double dx = GetLargeurSegment();
		double freq = gestionnaireNiveau.getNoiseFrequence();
		double noiseStep = dx * freq;

		double yDebut = CalculerY(noiseCurseur);
		double yFin = CalculerY(noiseCurseur + noiseStep);

		noiseCurseur += noiseStep;

		Segment s = new Segment(0, yDebut, dx, yFin - yDebut);
		s.setCouleur(new Color(0.2f, 0.2f, 0.2f));

		return s;
	}

	protected double CalculerY(double noisePos){
		double limiteHaut = gestionnaireNiveau.getLimiteHaut();
		double limiteBas = gestionnaireNiveau.getLimiteBas();
		double hauteur = limiteBas - limiteHaut;

		double bruit = noiseGenerator.noise(noisePos);
		double normalise = (bruit + 1) / 2;

		return limiteBas - normalise * hauteur;
	}

	@Override
	public void Afficher(Graphics g) {
		Graphics2D g2D = (Graphics2D) g;
		g2D.setStroke(new BasicStroke(3.0f));

		for (Segment s : listeSegments) {
			s.Afficher(g);
			if (SegCourant == null) {
				if (Cercle.xCercle <= s.x + s.xLong && Cercle.xCercle >= s.x) {
					SegCourant = s;
				}
			} else {
				if ((SegCourant.x + SegCourant.xLong) < Cercle.xCercle) {
					if (s.x <= Cercle.xCercle && (s.x + s.xLong) >= Cercle.xCercle) {
						SegCourant = s;
					}
				}
			}
		}
	}

	@Override
	public void Animer() {
		double vitesse = gestionnaireNiveau.getVitesseScroll();

		for (Segment s : listeSegments) {
			s.Animer();
			s.x -= vitesse;
		}

		UpdateSegments();
	}

	private void UpdateSegments(){

		if (dernierSegment == null) throw new RuntimeException("dernierSegment n'existe pas");

        for (int i = 0; i < listeSegments.size(); i++) {

            Segment s = listeSegments.get(i);
            if (s.x + s.xLong < 0) {
                Segment nouveauSegment = CreerSegmentSuivant();
				nouveauSegment.x = dernierSegment.x + dernierSegment.xLong;
				listeSegments.set(i, nouveauSegment);

				xActuel += GetLargeurSegment();
				dernierSegment = nouveauSegment;
            }
        }
	}

	public double GetHauteurPointCercle(){
		double t = (400 - SegCourant.x) / SegCourant.xLong;

		return SegCourant.y + SegCourant.yLong * t;
	}
}
