package model;

import java.awt.RenderingHints.Key;
import java.util.ArrayList;

import application.Main;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleDoubleProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.scene.input.KeyCode;
import javafx.scene.input.KeyEvent;
import vue.SceneJeu;

/**
 * Classe modèle parente de tous les objets personnage du jeu. Sert
 * temporairement pour le joueur seulement.
 *
 * @author Élie Bédard, Diego Cabas, Vincent McKibbin
 *
 */
public class Personnage extends Acteur {
	private static final int POINTS_DE_VIE=30;
	/**
	 * Vitesse de déplacement horizontal du personnage.
	 */
	private double vitesseX;

	/**
	 * Vitesse de déplacement vertical du personnage.
	 */
	private double vitesseY;

	/**
	 * Points de vie du personnage.
	 */
	private int hp;

	/**
	 * Valeur de constante de gravité horizontale.
	 */
	private double gravityX;

	/**
	 * Valeur de constante de gravité verticale.
	 */
	private double gravityY;

	private IntegerProperty vies;

	private boolean veutsauter = false;

	private int dommage;//

	/**
	 * Constructeur par défaut. Ne sert temporairement que pour un joueur avec des
	 * valeurs par défaut.
	 */
	public Personnage() {
		super(0, 0, 30, 30);
		setVitesseX(0);
		setVitesseY(0);
		setHp(POINTS_DE_VIE);
		//vies = new SimpleIntegerProperty(2);
		setGravityX(0);
		setGravityY(GRAV);
		setDommage(0);

	}

	public Personnage(double x, double y, double dX, double dY) {
		super(x, y, dX, dY);
		setGravityX(0);
		setGravityY(GRAV);
	}

	/**
	 * Vérifie s'il en est capable, et déplace le personnage pour une distance dans
	 * un frame d'animation.
	 *
	 * @param p Plateforme ou obstacle pouvant empêcher le mouvement.
	 */
	public void deplacement() {

		for (Acteur a : Main.getJeu().getActeurs()) {
			if (a instanceof Plateforme) {
				Plateforme p = (Plateforme) a;

				if (collisionPlateformeToTheLeft(p)) {
					// System.out.println("PlateformeXGauche");
				//	setPosX(p.getDimX() + p.getPosX());
				//	super.getHitBox().setX(getPosX());

					if (getVitesseX() < 0) {
						setVitesseX(0);
						setPosX(p.getDimX() + p.getPosX());
						super.getHitBox().setX(getPosX());
					}
				}
				if (collisionPlateformeToTheRight(p)) {
					// System.out.println("PlateformeXDroite");
				//	setPosX(p.getPosX() - getDimX());
				//	super.getHitBox().setX(getPosX());

					if (getVitesseX() > 0) {
						setVitesseX(0);
						setPosX(p.getPosX() - getDimX());
						super.getHitBox().setX(getPosX());
					}

				}

				if (collisionPlateformeOnTop(p)) {
					// System.out.println("PlateformePlafond");


					if (getVitesseY() < 0) {
						setVitesseY(0);
						setPosY(p.getDimY() + p.getPosY());
						super.getHitBox().setY(getPosY());
					}
				}
				if (collisionPlateformeOnBottom(p)) {
					// System.out.println("PlateformePlancher");


					if (getVitesseY() > 0) {
						setVitesseY(0);
						setPosY(p.getPosY() - getDimY());
						super.getHitBox().setY(getPosY());
					}

				}
			}


//				if(this instanceof Projectile&& this.collision(a)){///
//					this.setPosY(2000);
//				}
			if(getHp()<0){//=
                setHp(POINTS_DE_VIE);
                    setPosX(10);//
                setPosY(10);
                System.out.println(getHp());
            }


		}

		// if(collsionPlateformeXD(p)){
		// System.out.println("dddddddddd");
		//
		// setPosX(getDimX()+p.getPosX());
		// setVitesseX(0);
		//
		// }

		setPosX(getPosX() + getVitesseX());
		setPosY(getPosY() + getVitesseY());
		super.getHitBox().setX(getPosX());
		super.getHitBox().setY(getPosY());
		// setVitesseX(getVitesseX() + getGravityX());
		// if(jeu.getJoueur().collisionPlateformeY(jeu.getActeurs()))
		setGravityY(GRAV);
		setVitesseY(getVitesseY() + getGravityY());

//			if (collisionPlateformePlafond(p)) {
//				System.out.println("PlateformePlafond");
//				setVitesseY(0);
//				setPosY(p.getPosY() + p.getDimY());

	}
//		} else {
//
//			if (collisionPlateformePlancher(p)) {
//				if (getVitesseY() < 0) {
//					setVitesseY(getVitesseY());
//				} else {
//					setVitesseY(0);
//
//				}
//				setPosY(p.getPosY() - getDimY());
//			}

	/**
	 * Donne une valeur de vitesse verticale initiale au personnage. Cette valeur
	 * diminue avec la constante gravitationnelle.
	 */
	public void saut() {
		// le saut va devoir �tre calcul� selon la gravit� x et y lors de
		// l'impl�mentation
		setVitesseY(-5);
	}

	public void peutSauter(Plateforme p) {
		// veutsauter va devoir �tre conditionnel quand on aura de la gravit� dans
		// diff�rentes directions

		veutsauter = collisionPlateformeOnBottom(p);
	}

	public Projectile lancerProjectile(double x, double y) {
		// tangente entre -pi/2 et pi/2
		double angle = (((getPosY() - y) >= 0 && (x - getPosX()) >= 0) || ((getPosY() - y) < 0) && (x - getPosX()) >= 0)
				? Math.atan((getPosY() - y) / (x - getPosX()))
				: Math.atan((getPosY() - y) / (x - getPosX())) + Math.PI;
		return new Projectile(angle, this);
	}

	/**
	 * Vérifie si le personnage entre en collision avec une plateforme dans l'axe
	 * vertical.
	 *
	 * @param p Plateforme avec laquelle on vérifie la collision.
	 * @return True s'il y a une collision, sinon false.
	 */
//	private boolean collisionPlateformePlafondY(Plateforme p) {
//		return getPosY() <= p.getPosY() + p.getDimY();
//	}

	/**
	 * V�rifie si le personnage entre en collision avec une plateforme.
	 *
	 * @param p Plateforme avec laquelle on v�rifie la collision.
	 * @return True s'il y a une collision, sinon false.
	 */
	private boolean collisionPlateforme(Plateforme p) {

		return (super.getHitBox().intersects(p.getHitBox().getBoundsInParent()));
//				&& collisionPlateformePlancher(p);

	}

	/**
	 * V�rifie si la partie sup�rieure du personnage entre en collision avec une
	 * plateforme dans l'axe vertical.
	 *
	 * @param p Plateforme avec laquelle on v�rifie la collision.
	 * @return True s'il y a une collision, sinon false.
	 */

	private boolean collisionPlateformeOnTop(Plateforme p) {

		return (collisionPlateforme(p) && getPosY() <= p.getPosY() + p.getDimY()
				&& getPosY() + getDimY() > p.getPosY() + p.getDimY() && positionCorrespondEnX(p));

		// return (getPosY() >= p.getPosY() + p.getDimY() / 2) &&
		// (collisionPlateformePlafondY(p)) && positionCorrespondEnX(p);
	}

	/**
	 * V�rifie si la partie inf�rieur du personnage entre en collision avec une
	 * plateforme dans l'axe vertical.
	 *
	 * @param p Plateforme avec laquelle on v�rifie la collision.
	 * @return True s'il y a une collision, sinon false.
	 */

	public boolean collisionPlateformeOnBottom(Plateforme p) {
		return (collisionPlateforme(p) && getPosY() + getDimY() >= p.getPosY() && getPosY() < p.getPosY()
				&& positionCorrespondEnX(p));
	}

	/**
	 * V�rifie si la partie gauche du personnage entre en collision avec une
	 * plateforme dans l'axe horizontale.
	 *
	 * @param p Plateforme avec laquelle on v�rifie la collision.
	 * @return True s'il y a une collision, sinon false.
	 */
	private boolean collisionPlateformeToTheLeft(Plateforme p) {
		return (collisionPlateforme(p) && getPosX() <= p.getPosX() + p.getDimX()
				&& getPosX() + getDimX() > p.getPosX() + p.getDimX() && positionCorrespondEnY(p));
	}

	/**
	 * V�rifie si la partie droite du personnage entre en collision avec une
	 * plateforme dans l'axe horizontale.
	 *
	 * @param p Plateforme avec laquelle on v�rifie la collision.
	 * @return True s'il y a une collision, sinon false.
	 */
	private boolean collisionPlateformeToTheRight(Plateforme p) {
		return (collisionPlateforme(p) && getPosX() + getDimX() >= p.getPosX() && getPosX() < p.getPosX()
				&& positionCorrespondEnY(p));
	}

	/**
	 * V�rifie si le joueur est allign� avec une platforme sur l'axe horizontale
	 *
	 * @param p Plateforme avec laquelle on v�rifie l'allignement.
	 * @return True si le joueur est allign�, sinon false.
	 */

	private boolean positionCorrespondEnY(Plateforme p) {
		return (getPosY() + getDimY() > p.getPosY()) && (getPosY() < p.getPosY() + p.getDimY());
	}

	/**
	 * V�rifie si le joueur est allign� avec une platforme sur l'axe verticale
	 *
	 * @param p Plateforme avec laquelle on v�rifie l'allignement.
	 * @return True si le joueur est allign�, sinon false.
	 */
	private boolean positionCorrespondEnX(Plateforme p) {
		return (getPosX() + getDimX() > p.getPosX()) && (getPosX() < p.getPosX() + p.getDimX());
	}

	public double getVitesseX() {
		return vitesseX;
	}

	public void setVitesseX(double vitX) {
		this.vitesseX = vitX;
	}

	public double getVitesseY() {
		return vitesseY;
	}

	public void setVitesseY(double vitY) {
		this.vitesseY = vitY;
	}

//	public DoubleProperty getHpProperty() {
//		return hp;
//	}

//	public double getHp() {
//		return hp.get();
//	}
//
//	public void setHp(double newhp) {
//		this.hp.set(newhp);
//	}

	public double getGravityX() {
		return gravityX;
	}

	public void setGravityX(double grav) {
		this.gravityX = grav;
	}

	public double getGravityY() {
		return gravityY;
	}

	public void setGravityY(double grav) {
		this.gravityY = grav;
	}

	public boolean isVeutsauter() {
		return veutsauter;
	}

	public void setVeutsauter(boolean veutsauter) {
		this.veutsauter = veutsauter;
	}

	public int getDommage() {
		return dommage;
	}

	public void setDommage(int dommage) {
		this.dommage = dommage;
	}

	public IntegerProperty viesProperty() {
		return vies;
	}

	public int getVies() {
		return vies.get();
	}

	public void setVies(int vies) {
		this.vies.set(vies);
	}

	public void collisions() {// collisions avec ennemis
		for (Acteur a : Main.getJeu().getActeurs()) {

			if (a instanceof Personnage) {

				Personnage p = (Personnage) a;

				if (collision(p) && !p.equals(this)) {// intersects

					setHp(getHp() - p.getDommage());

				}
			}
		}

		for (Projectile p : Main.getJeu().getProjectiles()) {
			if (collision(p) && p.getSource() != this) {
				System.out.println(p.getSource());
				System.out.println(this);
				setHp(getHp() - p.getDommage());

				System.out.println(getHp());
				p.setDommageTest(true);
			}
		}
	}

	public int getHp() {
		return hp;
	}

	public void setHp(int hp) {
		this.hp = hp;
	}

	// }
	public boolean collision(Acteur a) {

		return a.getPosX() + a.getDimX() > getPosX() && a.getPosX() < getPosX() + getDimX()
				&& a.getPosY() + a.getDimY() > getPosY() && a.getPosY() < getPosY() + getDimY();

	}
}