import fs, {closeSync, readFileSync, readSync, writeFileSync} from 'fs';
import * as PImage from 'pureimage';
import {Line} from 'pureimage/dist/line';

const DATA_START = 44;

type Options = {
	width: number;
	height: number;
	rms: boolean;
	maximums: boolean;
	average: boolean;
	start: 'START';
	end: 'END';
	colors: {
		maximums: string;
		rms: string;
		background: string;
	};
	filename: string;
};

type Sample = {
	posRms?: number;
	negRms?: number;
	posMax?: number;
	negMax?: number;
};

const wavToBitmap = (
	imageData: Uint8Array,
	width: number,
	height: number,
): Uint8Array => {
	// BMP file header and DIB header size
	const fileHeaderSize = 14;
	const dibHeaderSize = 40;

	// The width must be a multiple of 4 bytes in a BMP file
	const rowBytes = 4 * Math.ceil((3 * width) / 4);
	const pixelArraySize = rowBytes * height;

	// File size is the header size plus the actual pixel data
	const fileSize = fileHeaderSize + dibHeaderSize + pixelArraySize;

	// Create a buffer for the BMP file
	const buffer = new ArrayBuffer(fileSize);
	const view = new DataView(buffer);

	// BMP File header
	view.setUint8(0, 0x42); // 'B'
	view.setUint8(1, 0x4d); // 'M'
	view.setUint32(2, fileSize, true); // File size
	view.setUint32(6, 0, true); // Reserved
	view.setUint32(10, fileHeaderSize + dibHeaderSize, true); // Pixel data offset

	// DIB header
	view.setUint32(14, dibHeaderSize, true); // DIB header size
	view.setInt32(18, width, true); // Image width
	view.setInt32(22, -height, true); // Image height (negative indicates top-down DIB)
	view.setUint16(26, 1, true); // Number of color planes
	view.setUint16(28, 24, true); // Bits per pixel
	view.setUint32(30, 0, true); // No compression (BI_RGB)
	view.setUint32(34, pixelArraySize, true); // Size of raw bitmap data (including padding)
	view.setUint32(38, 2835, true); // Print resolution X (72 DPI × 39.3701 inches/meter)
	view.setUint32(42, 2835, true); // Print resolution Y
	view.setUint32(46, 0, true); // Number of colors in the palette
	view.setUint32(50, 0, true); // Important colors

	// Pixel data
	const imageDataOffset = fileHeaderSize + dibHeaderSize;
	for (let y = 0; y < height; y++) {
		for (let x = 0; x < width; x++) {
			const srcIndex = (y * width + x) * 4;
			const destIndex = imageDataOffset + y * rowBytes + x * 3;
			view.setUint8(destIndex + 2, imageData[srcIndex]); // Red
			view.setUint8(destIndex + 1, imageData[srcIndex + 1]); // Green
			view.setUint8(destIndex, imageData[srcIndex + 2]); // Blue
		}
	}

	return new Uint8Array(buffer);
};

const getStringBE = (bytes: Buffer) => {
	const arr = Array.prototype.slice.call(bytes, 0);
	let result = '';
	for (let i = 0; i < arr.length; i += 1) {
		result += String.fromCharCode(arr[i]);
	}

	return result;
};

type Chunk =
	| {
			type: 'fmt';
			chunkSize: number;
			audioFormat: number;
			numChannels: number;
			sampleRate: number;
			byteRate: number;
			blockAlign: number;
			bitsPerSample: number;
	  }
	| {
			type: 'data';
			chunkSize: number;
	  }
	| {
			type: 'list';
			chunkSize: number;
			listTypeId: number;
	  };

const readChunk = (
	buf: Buffer,
	currentOffset: number,
): {chunk: Chunk; offset: number} => {
	const subChunk = getStringBE(buf.slice(currentOffset, currentOffset + 4));
	if (subChunk === 'fmt ') {
		const chunkSize = buf.readInt32LE(currentOffset + 4);
		const audioFormat = buf.readUInt16LE(currentOffset + 8);
		const numChannels = buf.readUInt16LE(currentOffset + 10);
		const sampleRate = buf.readInt32LE(currentOffset + 12);
		const byteRate = buf.readInt32LE(currentOffset + 16);
		const blockAlign = buf.readUInt16LE(currentOffset + 20);
		const bitsPerSample = buf.readUInt16LE(currentOffset + 22);
		return {
			chunk: {
				audioFormat,
				bitsPerSample,
				blockAlign,
				byteRate,
				numChannels,
				sampleRate,
				chunkSize,
				type: 'fmt',
			},
			offset: currentOffset + 8 + chunkSize,
		};
	}

	if (subChunk === 'data') {
		const chunkSize = buf.readInt32LE(currentOffset + 4);
		return {
			chunk: {
				chunkSize,
				type: 'data',
			},
			offset: currentOffset + 8 + chunkSize,
		};
	}

	if (subChunk === 'LIST') {
		const chunkSize = buf.readInt32LE(currentOffset + 4);
		const listTypeId = buf.readInt32LE(currentOffset + 8);
		return {
			chunk: {
				chunkSize,
				type: 'list',
				listTypeId,
			},
			offset: currentOffset + 8 + chunkSize,
		};
	}

	throw new Error('Invalid chunk type');
};

export class Wavedraw {
	path: string;
	chunks: Chunk[];

	constructor(path: string) {
		if (!path) {
			throw new Error('path to wave file must be included in constructor');
		}

		this.path = path;
		this.chunks = this.getHeader();
	}

	getHeader() {
		const buf = readFileSync(this.path);

		let currentOffset = 12;
		const chunks: Chunk[] = [];
		while (currentOffset < buf.length) {
			const {chunk, offset} = readChunk(buf, currentOffset);
			currentOffset = offset;
			chunks.push(chunk);
		}

		return chunks;
	}

	getChunk(type: Chunk['type']) {
		const found = this.chunks.find((chunk) => chunk.type === type);
		if (!found) {
			throw new Error(`Chunk type ${type} not found`);
		}

		return found;
	}

	getFileLength() {
		const chunk = this.getChunk('fmt');
		if (chunk.type !== 'fmt') {
			throw new Error('fmt chunk not found');
		}

		const numSamples = parseInt(
			(chunk.chunkSize / chunk.blockAlign) as unknown as string,
			10,
		);
		let seconds = parseInt(
			(numSamples / chunk.sampleRate) as unknown as string,
			10,
		);
		const minutes = parseInt((seconds / 60) as unknown as string, 10);
		const hours = parseInt((minutes / 60) as unknown as string, 10);
		seconds %= 60;
		return {
			seconds,
			minutes,
			hours,
		};
	}

	getOffsetInfo(
		start: undefined | 'START',
		end: undefined | 'END',
		width: number,
	) {
		let startPos;
		let endPos;

		if (start === undefined || start === 'START') {
			startPos = DATA_START;
		} else {
			startPos = this.getOffset(start) + DATA_START;
		}

		if (end === undefined || end === 'END') {
			const chunk = this.getChunk('data');
			if (chunk.type !== 'data') {
				throw new Error('data chunk not found');
			}

			endPos = chunk.chunkSize;
		} else {
			endPos = this.getOffset(end);
		}

		const fmt = this.getChunk('fmt');
		if (fmt.type !== 'fmt') {
			throw new Error('fmt chunk not found');
		}

		const blockSize = parseInt(
			(((endPos as number) - startPos) /
				(fmt.blockAlign as number) /
				width) as unknown as string,
			10,
		);
		const chunkSize = parseInt(
			(blockSize * (fmt.blockAlign as number)) as unknown as string,
			10,
		);
		return {
			startPos,
			endPos,
			blockSize,
			chunkSize,
		};
	}

	getOffset(time: string) {
		const [hours, minutes, seconds] = time
			.split(':')
			.map((unit) => parseInt(unit, 10));

		let adjustedSeconds = seconds + hours * 60 * 60;
		adjustedSeconds += minutes * 60;
		const fmt = this.getChunk('fmt');
		if (fmt.type !== 'fmt') {
			throw new Error('fmt chunk not found');
		}

		return parseInt(
			(adjustedSeconds *
				(fmt.sampleRate as number) *
				(fmt.blockAlign as number)) as unknown as string,
			10,
		);
	}

	static validateDrawWaveOptions(options: {width?: number; height?: number}) {
		if (!(options.width && options.height)) {
			throw new Error('drawWave() required parameters: width, height');
		}
	}

	drawWave(options: Options) {
		Wavedraw.validateDrawWaveOptions(options);
		const fmt = this.getChunk('fmt');
		if (fmt.type !== 'fmt') {
			throw new Error('fmt chunk not found');
		}

		if (fmt.bitsPerSample !== 16) {
			throw new Error('drawWave() currently only supports 16 bit audio files!');
		}

		const samples = this.getSamples(options);
		const img1 = PImage.make(options.width, options.height);
		const ctx = img1.getContext('2d');
		const ceiling = 32767;

		if (options.colors && options.colors.background) {
			ctx.fillStyle = options.colors.background;
			ctx.fillRect(0, 0, options.width, options.height);
		}

		for (let i = 0; i < options.width; i += 1) {
			if (options.maximums) {
				ctx.strokeStyle =
					options.colors && options.colors.maximums
						? options.colors.maximums
						: '#0000ff';

				ctx.drawLine(
					new Line(
						i,
						Number.parseInt((options.height / 2) as unknown as string, 10),
						i,
						Number.parseInt(
							(options.height / 2 -
								(options.height / 2 / ceiling) *
									(samples[i].posMax as number)) as unknown as string,
							10,
						),
					),
				);

				ctx.drawLine(
					new Line(
						i,
						Number.parseInt((options.height / 2) as unknown as string, 10),
						i,
						Number.parseInt(
							(options.height / 2 +
								-(
									(options.height / 2 / ceiling) *
									(samples[i].negMax as number)
								)) as unknown as string,
							10,
						),
					),
				);
			}

			if (options.rms) {
				ctx.strokeStyle =
					options.colors && options.colors.rms ? options.colors.rms : '#659df7';
				ctx.drawLine(
					new Line(
						i,
						Number.parseInt((options.height / 2) as unknown as string, 10),
						i,
						Number.parseInt(
							(options.height / 2 -
								(options.height / 2 / ceiling) *
									(samples[i].posRms as number)) as unknown as string,
							10,
						),
					),
				);

				ctx.drawLine(
					new Line(
						i,
						Number.parseInt((options.height / 2) as unknown as string, 10),
						i,
						Number.parseInt(
							(options.height / 2 +
								-(
									(options.height / 2 / ceiling) *
									(samples[i].negRms as number)
								)) as unknown as string,
							10,
						),
					),
				);
			}
		}

		const {filename} = options;

		const currentFile = readFileSync(filename);

		const data = ctx.getImageData(0, 0, options.width, options.height);
		const arr = wavToBitmap(data.data, options.width, options.height);

		writeFileSync(filename, arr);

		if (currentFile.length !== arr.length) {
			throw new Error('Waveform file sizes are different');
		}

		let differences = 0;
		for (let i = 0; i < currentFile.length; i += 1) {
			if (currentFile[i] !== arr[i]) {
				differences += 1;
			}
		}

		const percentWrong = (differences / currentFile.length) * 100;

		if (percentWrong > 0.02) {
			throw new Error(
				`Waveforms are different, ${percentWrong} differences found`,
			);
		}
	}

	getSamples(options: Options) {
		if (!options.width) {
			throw new Error('getSamples() required parameter: width');
		}

		const offsetInfo = this.getOffsetInfo(
			options.start,
			options.end,
			options.width,
		);
		const file = fs.openSync(this.path, 'r');
		if (!file) {
			throw new Error(`Error opening file ${this.path}`);
		}

		const samples: Sample[] = [];
		for (let x = 0; x < options.width; x += 1) {
			const buf = new ArrayBuffer(offsetInfo.chunkSize);
			const intView = new Int16Array(buf);
			const position = offsetInfo.chunkSize * x + offsetInfo.startPos;
			readSync(file, intView, 0, offsetInfo.chunkSize, position);
			let sampleInfo = {};
			if (options.maximums) sampleInfo = {...Wavedraw.computeMaximums(intView)};
			if (options.average)
				sampleInfo = {...sampleInfo, ...Wavedraw.computeAverage(intView)};
			if (options.rms)
				sampleInfo = {...sampleInfo, ...Wavedraw.computeRms(intView)};
			samples.push(sampleInfo);
		}

		closeSync(file);
		return samples;
	}

	static computeMaximums(inputSignal: Int16Array) {
		return {
			posMax: Math.max.apply(null, inputSignal as unknown as number[]),
			negMax: Math.min.apply(null, inputSignal as unknown as number[]),
		};
	}

	static computeRms(inputSignal: Int16Array) {
		const positives = inputSignal.filter((x) => x >= 0);
		const posInt32 = Int32Array.from(positives);
		const posRms =
			posInt32.length > 0
				? Math.sqrt(
						posInt32.map((x) => x * x).reduce((a, b) => a + b, 0) /
							posInt32.length,
					)
				: 0;
		const negatives = inputSignal.filter((x) => x < 0);
		const negInt32 = Int32Array.from(negatives);
		const negRms =
			negInt32.length > 0
				? -Math.sqrt(
						Math.abs(negInt32.map((x) => x * x).reduce((a, b) => a + b, 0)) /
							negInt32.length,
					)
				: 0;
		return {
			posRms,
			negRms,
		};
	}

	static computeAverage(inputSignal: Int16Array) {
		const positives = inputSignal.filter((x) => x >= 0);
		const posAvg =
			positives.length > 0
				? positives.reduce((a, b) => a + b, 0) / positives.length
				: 0;
		const negatives = inputSignal.filter((x) => x < 0);
		const negAvg =
			negatives.length > 0
				? negatives.reduce((a, b) => a + b, 0) / negatives.length
				: 0;
		return {
			posAvg,
			negAvg,
		};
	}

	static computeDft(inputSignal: Int16Array) {
		const N = inputSignal.length;
		const pi2 = Math.PI * 2.0;
		const dftValues = [];
		for (let i = 0; i < N; i += 1) {
			dftValues[i] = {
				real: 0.0,
				imag: 0.0,
			};
			for (let j = 0; j < N; j += 1) {
				dftValues[i].real += inputSignal[j] * Math.cos((pi2 * j * i) / N);
				dftValues[i].imag += inputSignal[j] * Math.sin((pi2 * j * i) / N);
			}
		}

		return dftValues;
	}
}