import { Vector, VectorInteger } from "./Vector.js";
import { Component, Moving } from "./interface.js";

class Rectangle implements Component {
	pos: VectorInteger;
	width: number;
	height: number;
	constructor(pos: VectorInteger, width: number, height: number) {
		this.pos = Object.assign({}, pos);
		this.width = width;
		this.height = height;
	}
	collision(collider: Rectangle): boolean { // Collision WIP. To redo
		var myleft = this.pos.x;
		var myright = this.pos.x + (this.width);
		var mytop = this.pos.y;
		var mybottom = this.pos.y + (this.height);
		var otherleft = collider.pos.x;
		var otherright = collider.pos.x + (collider.width);
		var othertop = collider.pos.y;
		var otherbottom = collider.pos.y + (collider.height);
		if ((mybottom < othertop)
		|| (mytop > otherbottom)
		|| (myright < otherleft)
		|| (myleft > otherright)) {
			return false;
		}
		else
			return true;
	}
}

class MovingRectangle extends Rectangle implements Moving {
	dir: Vector = new Vector(0,0);
	speed: number;
	readonly baseSpeed: number;
	constructor(pos: VectorInteger, width: number, height: number, baseSpeed: number) {
		super(pos, width, height);
		this.baseSpeed = baseSpeed;
		this.speed = baseSpeed;
	}
	move(delta: number) { // Math.floor WIP until VectorInteger debug
		// console.log("delta: "+ delta);
		// console.log("speed: "+ this.speed);
		// console.log("speed*delta: "+ this.speed * delta);
		this.pos.x += Math.floor(this.dir.x * this.speed * delta);
		this.pos.y += Math.floor(this.dir.y * this.speed * delta);
	}
	moveAndCollide(delta: number, colliderArr: Rectangle[]) {
		let oldPos = Object.assign({}, this.pos);
		this.move(delta);
		if (colliderArr.some(this.collision, this))
		{
			this.pos.x = oldPos.x;
			this.pos.y = oldPos.y;
		}
	}
}

class Racket extends MovingRectangle {
	constructor(pos: VectorInteger, width: number, height: number, baseSpeed: number) {
		super(pos, width, height, baseSpeed);
	}
}

class Ball extends MovingRectangle {
	constructor(pos: VectorInteger, size: number, baseSpeed: number) {
		super(pos, size, size, baseSpeed);
	}
	bounce(collider?: Rectangle) {
		this._bounceAlgo(collider);
	}
	protected _bounceAlgo(collider?: Rectangle) {
		/* Could be more generic, but testing only Racket is enough,
		because in Pong collider can only be Racket or Wall. */
		if (collider instanceof Racket) {
			this._bouncePlayer(collider);
		}
		else {
			this._bounceWall();
		}
	}
	moveAndBounce(delta: number, colliderArr: Rectangle[]) {
		this.move(delta);
		let i = colliderArr.findIndex(this.collision, this);
		if (i != -1)
		{
			this.bounce(colliderArr[i]);
			this.move(delta);
		}
	}
	protected _bounceWall() { // Should be enough for Wall
		this.dir.y = this.dir.y * -1;
	}
	protected _bouncePlayer(collider: Racket) {
		this._bouncePlayerAlgo(collider);
	}
	protected _bouncePlayerAlgo(collider: Racket) { // WIP
		// Bounce for Racket need to be more complexe than this
		this.speed += this.baseSpeed/20;
		this.dir.x = this.dir.x * -1;
	}
}

export {Rectangle, MovingRectangle, Racket, Ball}