export interface BoidParams {
	topologicalK: number;
	perception: number;
	sepRange: number;
	maxSpeed: number;
	minSpeed: number;
	maxForce: number;
	wSep: number;
	wAlign: number;
	wCoh: number;
	wAttract: number;
	wNoise: number;
}

export const DEFAULT_BOID_PARAMS: BoidParams = {
	topologicalK: 7,
	perception: 70,
	sepRange: 14,
	maxSpeed: 3.4,
	minSpeed: 2.2,
	maxForce: 0.12,
	wSep: 1.8,
	wAlign: 1.4,
	wCoh: 0.9,
	wAttract: 0.06,
	wNoise: 0.015,
};

export const boidParams: BoidParams = { ...DEFAULT_BOID_PARAMS };

export class Boid {
	x: number;
	y: number;
	vx: number;
	vy: number;
	ax = 0;
	ay = 0;
	lastCell = -1;
	lastSepMag = 0;
	lastAccentAt = 0;

	constructor(W: number, H: number) {
		this.x = Math.random() * W;
		this.y = Math.random() * H;
		const a = Math.random() * Math.PI * 2;
		const s =
			boidParams.minSpeed +
			Math.random() * (boidParams.maxSpeed - boidParams.minSpeed);
		this.vx = Math.cos(a) * s;
		this.vy = Math.sin(a) * s;
	}

	edges(W: number, H: number) {
		const m = 20;
		if (this.x < -m) this.x = W + m;
		else if (this.x > W + m) this.x = -m;
		if (this.y < -m) this.y = H + m;
		else if (this.y > H + m) this.y = -m;
	}

	flock(candidates: Boid[], attractor: { x: number; y: number }) {
		const p = boidParams;
		const perception2 = p.perception * p.perception;
		const sepRange2 = p.sepRange * p.sepRange;

		const dists: { o: Boid; d2: number; dx: number; dy: number }[] = [];
		for (let i = 0; i < candidates.length; i++) {
			const o = candidates[i];
			if (o === this) continue;
			const dx = o.x - this.x;
			const dy = o.y - this.y;
			const d2 = dx * dx + dy * dy;
			if (d2 < perception2 && d2 > 0) {
				dists.push({ o, d2, dx, dy });
			}
		}
		dists.sort((a, b) => a.d2 - b.d2);
		const k = Math.min(p.topologicalK, dists.length);

		let alignX = 0,
			alignY = 0;
		let cohX = 0,
			cohY = 0;
		let sepX = 0,
			sepY = 0;
		let sepCount = 0;

		for (let i = 0; i < k; i++) {
			const { o, d2, dx, dy } = dists[i];
			alignX += o.vx;
			alignY += o.vy;
			cohX += o.x;
			cohY += o.y;

			if (d2 < sepRange2) {
				const d = Math.sqrt(d2);
				const f = 1 / (d + 0.001);
				sepX -= (dx / d) * f;
				sepY -= (dy / d) * f;
				sepCount++;
			}
		}

		let fx = 0,
			fy = 0;

		if (k > 0) {
			alignX /= k;
			alignY /= k;
			const m = Math.hypot(alignX, alignY);
			if (m > 0) {
				alignX = (alignX / m) * p.maxSpeed - this.vx;
				alignY = (alignY / m) * p.maxSpeed - this.vy;
				const sm = Math.hypot(alignX, alignY);
				if (sm > p.maxForce) {
					alignX = (alignX / sm) * p.maxForce;
					alignY = (alignY / sm) * p.maxForce;
				}
				fx += alignX * p.wAlign;
				fy += alignY * p.wAlign;
			}

			cohX = cohX / k - this.x;
			cohY = cohY / k - this.y;
			const cm = Math.hypot(cohX, cohY);
			if (cm > 0) {
				cohX = (cohX / cm) * p.maxSpeed - this.vx;
				cohY = (cohY / cm) * p.maxSpeed - this.vy;
				const sm = Math.hypot(cohX, cohY);
				if (sm > p.maxForce) {
					cohX = (cohX / sm) * p.maxForce;
					cohY = (cohY / sm) * p.maxForce;
				}
				fx += cohX * p.wCoh;
				fy += cohY * p.wCoh;
			}
		}

		if (sepCount > 0) {
			const m = Math.hypot(sepX, sepY);
			if (m > 0) {
				sepX = (sepX / m) * p.maxSpeed - this.vx;
				sepY = (sepY / m) * p.maxSpeed - this.vy;
				const sm = Math.hypot(sepX, sepY);
				if (sm > p.maxForce * 2) {
					sepX = (sepX / sm) * p.maxForce * 2;
					sepY = (sepY / sm) * p.maxForce * 2;
				}
				fx += sepX * p.wSep;
				fy += sepY * p.wSep;
				this.lastSepMag = Math.hypot(sepX, sepY);
			} else {
				this.lastSepMag = 0;
			}
		} else {
			this.lastSepMag = 0;
		}

		const adx = attractor.x - this.x;
		const ady = attractor.y - this.y;
		const ad = Math.hypot(adx, ady);
		if (ad > 0) {
			fx += (adx / ad) * p.wAttract;
			fy += (ady / ad) * p.wAttract;
		}

		fx += (Math.random() - 0.5) * p.wNoise;
		fy += (Math.random() - 0.5) * p.wNoise;

		this.ax += fx;
		this.ay += fy;
	}

	update() {
		const p = boidParams;
		this.vx += this.ax;
		this.vy += this.ay;
		const sp = Math.hypot(this.vx, this.vy);
		if (sp > p.maxSpeed) {
			this.vx = (this.vx / sp) * p.maxSpeed;
			this.vy = (this.vy / sp) * p.maxSpeed;
		} else if (sp < p.minSpeed && sp > 0) {
			this.vx = (this.vx / sp) * p.minSpeed;
			this.vy = (this.vy / sp) * p.minSpeed;
		}
		this.x += this.vx;
		this.y += this.vy;
		this.ax = 0;
		this.ay = 0;
	}
}

export function flockCoherence(boids: Boid[]): number {
	let sumX = 0,
		sumY = 0,
		sumMag = 0;
	for (let i = 0; i < boids.length; i++) {
		const b = boids[i];
		sumX += b.vx;
		sumY += b.vy;
		sumMag += Math.hypot(b.vx, b.vy);
	}
	if (sumMag === 0) return 0;
	return Math.hypot(sumX, sumY) / sumMag;
}

export function drawBoid(ctx: CanvasRenderingContext2D, b: Boid) {
	const angle = Math.atan2(b.vy, b.vx);
	const cos = Math.cos(angle);
	const sin = Math.sin(angle);
	const len = 3.2;
	ctx.beginPath();
	ctx.moveTo(b.x - cos * len, b.y - sin * len);
	ctx.lineTo(b.x + cos * len * 0.6, b.y + sin * len * 0.6);
	ctx.stroke();
}

export type Sim = ReturnType<typeof createSim>;

export function createSim(W: number, H: number) {
	const state = {
		W,
		H,
		boids: [] as Boid[],
		attractor: {
			x: W / 2,
			y: H / 2,
			t: Math.random() * 1000,
		},
	};

	function defaultCount(W: number, H: number) {
		return Math.min(420, Math.floor((W * H) / 3200));
	}

	function spawn(count: number) {
		state.boids.length = 0;
		const cx0 = state.W / 2,
			cy0 = state.H / 2;
		for (let i = 0; i < count; i++) {
			const b = new Boid(state.W, state.H);
			const r = Math.random() * Math.min(state.W, state.H) * 0.25;
			const a = Math.random() * Math.PI * 2;
			b.x = cx0 + Math.cos(a) * r;
			b.y = cy0 + Math.sin(a) * r;
			state.boids.push(b);
		}
	}

	spawn(defaultCount(W, H));

	const grid = new Map<string, Boid[]>();

	function buildGrid() {
		grid.clear();
		const cellSize = boidParams.perception;
		for (let i = 0; i < state.boids.length; i++) {
			const b = state.boids[i];
			const cx = Math.floor(b.x / cellSize);
			const cy = Math.floor(b.y / cellSize);
			const k = cx + ',' + cy;
			let arr = grid.get(k);
			if (!arr) {
				arr = [];
				grid.set(k, arr);
			}
			arr.push(b);
		}
	}

	function neighbors(b: Boid): Boid[] {
		const cellSize = boidParams.perception;
		const cx = Math.floor(b.x / cellSize);
		const cy = Math.floor(b.y / cellSize);
		const out: Boid[] = [];
		for (let dx = -1; dx <= 1; dx++) {
			for (let dy = -1; dy <= 1; dy++) {
				const arr = grid.get(cx + dx + ',' + (cy + dy));
				if (arr) for (let i = 0; i < arr.length; i++) out.push(arr[i]);
			}
		}
		return out;
	}

	function updateAttractor() {
		const a = state.attractor;
		a.t += 0.003;
		const cx = state.W / 2,
			cy = state.H / 2;
		const rx = state.W * 0.32,
			ry = state.H * 0.28;
		a.x = cx + Math.sin(a.t * 1.3) * rx + Math.cos(a.t * 0.7) * rx * 0.3;
		a.y = cy + Math.cos(a.t * 1.1) * ry + Math.sin(a.t * 1.7) * ry * 0.25;
	}

	function step() {
		updateAttractor();
		buildGrid();
		for (let i = 0; i < state.boids.length; i++) {
			state.boids[i].flock(neighbors(state.boids[i]), state.attractor);
		}
		for (let i = 0; i < state.boids.length; i++) {
			state.boids[i].update();
			state.boids[i].edges(state.W, state.H);
		}
	}

	function resize(W: number, H: number) {
		state.W = W;
		state.H = H;
	}

	return { state, step, resize, spawn };
}