use std::io::{self, Read};

use byteorder::{LittleEndian, ReadBytesExt};
use num_enum::TryFromPrimitive;
use raise::yeet;

use crate::colors::ColorEncoding;
use crate::read_varuint;
use crate::TvgError;

const MAGIC: [u8; 2] = [0x72, 0x56];
pub const SUPPORTED_VERSION: u8 = 1;

/// The coordinate range defines how many bits a Unit value uses.
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive)]
#[repr(u8)]
pub enum CoordinateRange {
	/// Each [`Unit`] takes up 16 bits.
	#[default]
	Default = 0,
	/// Each [`Unit`] takes up 8 bits.
	Reduced = 1,
	/// Each [`Unit`] takes up 32 bits.
	Enhanced = 2,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive)]
#[repr(u8)]
pub enum Scale {
	_1 = 0,
	_2 = 1,
	_4 = 2,
	_8 = 3,
	_16 = 4,
	_32 = 5,
	_64 = 6,
	_128 = 7,
	_256 = 8,
	_512 = 9,
	_1024 = 10,
	_2048 = 11,
	_4096 = 12,
	_8192 = 13,
	_16384 = 14,
	_32768 = 15,
}

/// Each TVG file starts with a header defining some global values for the file
/// like scale and image size. This is a representation of the header, but not
/// necessarily an exact representation of the bits of a TVG header.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TvgHeader {
	/// Must always be [0x72, 0x56]
	magic: [u8; 2],
	/// Must be 1. For future versions, this field might decide how the rest of
	/// the format looks like.
	version: u8,
	/// Defines the number of fraction bits in a Unit value.
	scale: Scale,
	/// Defines the type of color information that is used in the
	/// [`ColorTable`].
	color_encoding: ColorEncoding,
	/// Defines the number of total bits in a Unit value and thus the overall
	/// precision of the file.
	coordinate_range: CoordinateRange,
	/// Encodes the maximum width of the output file in *display units*.
	///
	/// A value of 0 indicates that the image has the maximum possible width.
	width: u32,
	/// Encodes the maximum height of the output file in *display units*.
	///
	/// A value of 0 indicates that the image has the maximum possible height.
	height: u32,
	/// The number of colors in the color table.
	color_count: u32,
}

impl TvgHeader {
	pub fn read<R: Read>(reader: &mut R) -> Result<Self, TvgError> {
		// magic number is used as a first line defense against invalid data
		let magic = [reader.read_u8()?, reader.read_u8()?];
		if magic != MAGIC {
			yeet!(TvgError::InvalidFile);
		}

		// the version of tvg being used
		let version = reader.read_u8()?;
		if version != SUPPORTED_VERSION {
			yeet!(TvgError::UnsupportedVersion(version))
		}

		// scale, color_encoding, and coordinate_range are stored in one byte
		let byte = reader.read_u8()?;
		let scale = Scale::try_from_primitive(byte & 0b0000_1111).expect("invalid scale");
		let color_encoding = ColorEncoding::try_from_primitive((byte & 0b0011_0000) >> 4)
			.expect("invalid color encoding");
		let coordinate_range = CoordinateRange::try_from_primitive((byte & 0b1100_0000) >> 6)
			.expect("invalid coordinate range");

		// width and height depend on the coordinate range
		let width = read_unsigned_unit(coordinate_range, reader)?;
		let height = read_unsigned_unit(coordinate_range, reader)?;

		let color_count = read_varuint(reader)?;

		Ok(Self {
			magic,
			version,
			scale,
			color_encoding,
			coordinate_range,
			width,
			height,
			color_count,
		})
	}

	/// Defines the number of total bits in a Unit value and thus the overall
	/// precision of the file.
	pub fn coordinate_range(&self) -> CoordinateRange {
		self.coordinate_range
	}

	/// Defines the type of color information that is used in the [`ColorTable`].
	pub fn color_encoding(&self) -> ColorEncoding {
		self.color_encoding
	}

	/// Defines the number of fraction bits in a Unit value.
	pub fn scale(&self) -> Scale {
		self.scale
	}

	/// The number of colors in the [`ColorTable`].
	pub fn color_count(&self) -> u32 {
		self.color_count
	}
}

fn read_unsigned_unit<R: Read>(
	coordinate_range: CoordinateRange,
	bytes: &mut R,
) -> io::Result<u32> {
	Ok(match coordinate_range {
		CoordinateRange::Reduced => bytes.read_u8()? as u32,
		CoordinateRange::Default => bytes.read_u16::<LittleEndian>()? as u32,
		CoordinateRange::Enhanced => bytes.read_u32::<LittleEndian>()?,
	})
}