use crate::tiff::file::{Endian, TiffRead};
use crate::tiff::tags::{BitsPerSample, CfaPattern, CfaPatternDim, Compression, ImageLength, ImageWidth, SonyToneCurve, StripByteCounts, StripOffsets, Tag, WhiteBalanceRggbLevels};
use crate::tiff::values::CurveLookupTable;
use crate::tiff::{Ifd, TiffError};
use crate::{RawImage, SubtractBlack, Transform};
use rawkit_proc_macros::Tag;
use std::io::{Read, Seek};

#[allow(dead_code)]
#[derive(Tag)]
struct Arw2Ifd {
	image_width: ImageWidth,
	image_height: ImageLength,
	bits_per_sample: BitsPerSample,
	compression: Compression,
	cfa_pattern: CfaPattern,
	cfa_pattern_dim: CfaPatternDim,
	strip_offsets: StripOffsets,
	strip_byte_counts: StripByteCounts,
	sony_tone_curve: SonyToneCurve,
	white_balance_levels: Option<WhiteBalanceRggbLevels>,
}

pub fn decode<R: Read + Seek>(ifd: Ifd, file: &mut TiffRead<R>) -> RawImage {
	let ifd = ifd.get_value::<Arw2Ifd, _>(file).unwrap();

	assert!(ifd.strip_offsets.len() == ifd.strip_byte_counts.len());
	assert!(ifd.strip_offsets.len() == 1);
	assert!(ifd.compression == 32767);

	let image_width: usize = ifd.image_width.try_into().unwrap();
	let image_height: usize = ifd.image_height.try_into().unwrap();
	let bits_per_sample: usize = ifd.bits_per_sample.into();
	assert!(bits_per_sample == 12);

	let [cfa_pattern_width, cfa_pattern_height] = ifd.cfa_pattern_dim;
	assert!(cfa_pattern_width == 2 && cfa_pattern_height == 2);

	file.seek_from_start(ifd.strip_offsets[0]).unwrap();
	let mut image = sony_arw2_load_raw(image_width, image_height, ifd.sony_tone_curve, file).unwrap();

	// Converting the bps from 12 to 14 so that ARW 2.3.1 and 2.3.5 have the same 14 bps.
	image.iter_mut().for_each(|x| *x <<= 2);

	RawImage {
		data: image,
		width: image_width,
		height: image_height,
		cfa_pattern: ifd.cfa_pattern.try_into().unwrap(),
		maximum: (1 << 14) - 1,
		black: SubtractBlack::CfaGrid([512, 512, 512, 512]), // TODO: Find the correct way to do this
		transform: Transform::Horizontal,
		camera_model: None,
		camera_white_balance: ifd.white_balance_levels.map(|arr| arr.map(|x| x as f64)),
		white_balance: None,
		camera_to_rgb: None,
	}
}

fn as_u32(buffer: &[u8], endian: Endian) -> Option<u32> {
	Some(match endian {
		Endian::Little => u32::from_le_bytes(buffer.try_into().ok()?),
		Endian::Big => u32::from_be_bytes(buffer.try_into().ok()?),
	})
}

fn as_u16(buffer: &[u8], endian: Endian) -> Option<u16> {
	Some(match endian {
		Endian::Little => u16::from_le_bytes(buffer.try_into().ok()?),
		Endian::Big => u16::from_be_bytes(buffer.try_into().ok()?),
	})
}

fn sony_arw2_load_raw<R: Read + Seek>(width: usize, height: usize, curve: CurveLookupTable, file: &mut TiffRead<R>) -> Option<Vec<u16>> {
	let mut image = vec![0_u16; height * width];
	let mut data = vec![0_u8; width + 1];

	for row in 0..height {
		file.read_exact(&mut data[0..width]).unwrap();

		let mut column = 0;
		let mut data_index = 0;

		while column < width - 30 {
			let data_value = as_u32(&data[data_index..][..4], file.endian()).unwrap();
			let max = (0x7ff & data_value) as u16;
			let min = (0x7ff & data_value >> 11) as u16;
			let index_to_set_max = 0x0f & data_value >> 22;
			let index_to_set_min = 0x0f & data_value >> 26;

			let max_minus_min = max as i32 - min as i32;
			let shift_by_bits = (0..4).find(|&shift| (0x80 << shift) > max_minus_min).unwrap_or(4);

			let mut pixels = [0_u16; 16];
			let mut bit = 30;
			for (i, pixel) in pixels.iter_mut().enumerate() {
				*pixel = match () {
					_ if i as u32 == index_to_set_max => max,
					_ if i as u32 == index_to_set_min => min,
					_ => {
						let result = as_u16(&data[(data_index + (bit >> 3))..][..2], file.endian()).unwrap();
						let result = ((result >> (bit & 7)) & 0x07f) << shift_by_bits;

						bit += 7;

						(result + min).min(0x7ff)
					}
				};
			}

			for value in pixels {
				image[row * width + column] = curve.get((value << 1).into()) >> 2;

				// Skip between interlaced columns
				column += 2;
			}

			// Switch to the opposite interlaced columns
			column -= if column & 1 == 0 { 31 } else { 1 };

			data_index += 16;
		}
	}

	Some(image)
}