import type {Instruction} from '@remotion/paths';

const shortenVector = (vector: readonly [number, number], radius: number) => {
	const [x, y] = vector;
	const currentLength = Math.sqrt(x * x + y * y);
	const scalingFactor = (currentLength - radius) / currentLength;
	return [x * scalingFactor, y * scalingFactor] as const;
};

const scaleVectorToLength = (
	vector: readonly [number, number],
	length: number,
) => {
	const [x, y] = vector;
	const currentLength = Math.sqrt(x * x + y * y);
	const scalingFactor = length / currentLength;
	return [x * scalingFactor, y * scalingFactor] as const;
};

export const joinPoints = (
	points: [number, number][],
	{
		edgeRoundness,
		cornerRadius,
		roundCornerStrategy,
	}: {
		edgeRoundness: number | null;
		cornerRadius: number;
		roundCornerStrategy: 'arc' | 'bezier';
	},
) => {
	return points
		.map(([x, y], i): Instruction[] => {
			const prevPointIndex = i === 0 ? points.length - 2 : i - 1;
			const prevPoint = points[prevPointIndex];
			const nextPointIndex = i === points.length - 1 ? 1 : i + 1;
			const nextPoint = points[nextPointIndex];
			const middleOfLine = [(x + nextPoint[0]) / 2, (y + nextPoint[1]) / 2];
			const prevPointMiddleOfLine = [
				(x + prevPoint[0]) / 2,
				(y + prevPoint[1]) / 2,
			];
			const prevVector = [x - prevPoint[0], y - prevPoint[1]] as const;
			const nextVector = [nextPoint[0] - x, nextPoint[1] - y] as const;

			if (i === 0) {
				if (edgeRoundness !== null) {
					return [
						{
							type: 'M',
							x: middleOfLine[0],
							y: middleOfLine[1],
						},
					];
				}

				if (cornerRadius !== 0) {
					const computeRadius = shortenVector(nextVector, cornerRadius);

					return [
						{
							type: 'M',
							x: computeRadius[0] + x,
							y: computeRadius[1] + y,
						},
					];
				}

				return [
					{
						type: 'M',
						x,
						y,
					},
				];
			}

			if (cornerRadius && edgeRoundness !== null) {
				throw new Error(
					`"cornerRadius" and "edgeRoundness" cannot be specified at the same time.`,
				);
			}

			if (edgeRoundness === null) {
				if (cornerRadius === 0) {
					return [
						{
							type: 'L',
							x,
							y,
						},
					];
				}

				const prevVectorMinusRadius = shortenVector(prevVector, cornerRadius);
				const prevVectorLength = scaleVectorToLength(prevVector, cornerRadius);
				const nextVectorMinusRadius = scaleVectorToLength(
					nextVector,
					cornerRadius,
				);

				const firstDraw = [
					prevPoint[0] + prevVectorMinusRadius[0],
					prevPoint[1] + prevVectorMinusRadius[1],
				];

				return [
					{
						type: 'L',
						x: firstDraw[0],
						y: firstDraw[1],
					},
					roundCornerStrategy === 'arc'
						? {
								type: 'a',
								rx: cornerRadius,
								ry: cornerRadius,
								xAxisRotation: 0,
								dx: prevVectorLength[0] + nextVectorMinusRadius[0],
								dy: prevVectorLength[1] + nextVectorMinusRadius[1],
								largeArcFlag: false,
								sweepFlag: true,
							}
						: {
								type: 'C',
								x:
									firstDraw[0] + prevVectorLength[0] + nextVectorMinusRadius[0],
								y:
									firstDraw[1] + prevVectorLength[1] + nextVectorMinusRadius[1],
								cp1x: x,
								cp1y: y,
								cp2x: x,
								cp2y: y,
							},
				];
			}

			const controlPoint1 = [
				prevPointMiddleOfLine[0] + prevVector[0] * edgeRoundness * 0.5,
				prevPointMiddleOfLine[1] + prevVector[1] * edgeRoundness * 0.5,
			] as const;

			const controlPoint2 = [
				middleOfLine[0] - nextVector[0] * edgeRoundness * 0.5,
				middleOfLine[1] - nextVector[1] * edgeRoundness * 0.5,
			] as const;

			return [
				{
					type: 'C',
					cp1x: controlPoint1[0],
					cp1y: controlPoint1[1],
					cp2x: controlPoint2[0],
					cp2y: controlPoint2[1],
					x: middleOfLine[0],
					y: middleOfLine[1],
				},
			];
		})
		.flat(1);
};