use crate::RawImage;
use rawkit_proc_macros::build_camera_data;

pub struct CameraData {
	pub black: u16,
	pub maximum: u16,
	pub xyz_to_camera: [i16; 9],
}

impl CameraData {
	const DEFAULT: CameraData = CameraData {
		black: 0,
		maximum: 0,
		xyz_to_camera: [0; 9],
	};
}

const CAMERA_DATA: [(&str, CameraData); 40] = build_camera_data!();

const RGB_TO_XYZ: [[f64; 3]; 3] = [
	// Matrix:
	[0.412453, 0.357580, 0.180423],
	[0.212671, 0.715160, 0.072169],
	[0.019334, 0.119193, 0.950227],
];

impl RawImage {
	pub fn calculate_conversion_matrices(&mut self) {
		let Some(ref camera_model) = self.camera_model else { return };
		let camera_name_needle = camera_model.make.to_owned() + " " + &camera_model.model;

		let xyz_to_camera = CAMERA_DATA
			.iter()
			.find(|(camera_name_haystack, _)| camera_name_needle == *camera_name_haystack)
			.map(|(_, data)| data.xyz_to_camera.map(|x| (x as f64) / 10_000.));
		let Some(xyz_to_camera) = xyz_to_camera else { return };

		let mut rgb_to_camera = [[0.; 3]; 3];
		for i in 0..3 {
			for j in 0..3 {
				for k in 0..3 {
					rgb_to_camera[i][j] += RGB_TO_XYZ[k][j] * xyz_to_camera[i * 3 + k];
				}
			}
		}

		let white_balance_multiplier = rgb_to_camera.map(|x| 1. / x.iter().sum::<f64>());
		for (index, row) in rgb_to_camera.iter_mut().enumerate() {
			*row = row.map(|x| x * white_balance_multiplier[index]);
		}
		let camera_to_rgb = transpose(pseudoinverse(rgb_to_camera));

		let cfa_white_balance_multiplier = if let Some(white_balance) = self.camera_white_balance {
			white_balance
		} else {
			self.cfa_pattern.map(|index| white_balance_multiplier[index as usize])
		};

		self.white_balance = Some(cfa_white_balance_multiplier);
		self.camera_to_rgb = Some(camera_to_rgb);
	}
}

#[allow(clippy::needless_range_loop)]
fn pseudoinverse<const N: usize>(matrix: [[f64; 3]; N]) -> [[f64; 3]; N] {
	let mut output_matrix = [[0.; 3]; N];
	let mut work = [[0.; 6]; 3];

	for i in 0..3 {
		for j in 0..6 {
			work[i][j] = if j == i + 3 { 1. } else { 0. };
		}
		for j in 0..3 {
			for k in 0..N {
				work[i][j] += matrix[k][i] * matrix[k][j];
			}
		}
	}

	for i in 0..3 {
		let num = work[i][i];
		for j in 0..6 {
			work[i][j] /= num;
		}
		for k in 0..3 {
			if k == i {
				continue;
			}
			let num = work[k][i];
			for j in 0..6 {
				work[k][j] -= work[i][j] * num;
			}
		}
	}

	for i in 0..N {
		for j in 0..3 {
			output_matrix[i][j] = 0.;
			for k in 0..3 {
				output_matrix[i][j] += work[j][k + 3] * matrix[i][k];
			}
		}
	}

	output_matrix
}

fn transpose<const N: usize>(matrix: [[f64; 3]; N]) -> [[f64; N]; 3] {
	let mut output_matrix = [[0.; N]; 3];

	for (i, row) in matrix.iter().enumerate() {
		for (j, &value) in row.iter().enumerate() {
			output_matrix[j][i] = value;
		}
	}

	output_matrix
}