use core::fmt;
use std::num::{ParseIntError, ParseFloatError};

use thiserror::Error;

use crate::lstring::{LStr, LString};

use super::Span;

#[derive(Clone, Debug, Error)]
pub struct ParserError {
    pub span: Span,
    pub msg: String,
}

impl fmt::Display for ParserError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} | {}", self.span, self.msg)
    }
}

pub trait SpanParserError {
    type Output;
    fn span_err(self, span: Span) -> Self::Output;
}

impl<T, E: std::error::Error> SpanParserError for Result<T, E> {
    type Output = Result<T, ParserError>;
    fn span_err(self, span: Span) -> Self::Output {
        self.map_err(|e| ParserError { span, msg: e.to_string() })
    }
}

#[derive(Clone, Copy, Debug, Error)]
pub enum StrEscapeError {
	#[error("EOF in string escape")]
	Eof,
	#[error("EOF in string escape \\x")]
	HexEof,
	#[error("EOF in string escape \\u")]
	UnicodeEof,
	#[error("invalid string escape \\{0}")]
	Invalid(char),
	#[error("invalid hex digit '{0}' in string escape")]
	InvalidHex(char),
	#[error("missing brace after string escape \\u")]
	MissingBrace,
	#[error("invalid codepoint in string escape: {0:x}")]
	InvalidCodepoint(u32),
	#[error("codepoint in string escape too large")]
	CodepointTooLarge,
}

pub fn parse_str_escapes(src: &str) -> Result<LString, StrEscapeError> {
	let mut s = LString::with_capacity(src.len());
	let mut chars = src.chars();

	while let Some(c) = chars.next() {
		if c != '\\' { s.push_char(c); continue }
		let c = chars.next().ok_or(StrEscapeError::Eof)?;
		match c {
			'"' | '\'' | '\\' => s.push_char(c),
			'0'  => s.push_char('\0'),
			'a'  => s.push_char('\x07'),
			'b'  => s.push_char('\x08'),
			't'  => s.push_char('\t'),
			'n'  => s.push_char('\n'),
			'v'  => s.push_char('\x0b'),
			'f'  => s.push_char('\x0c'),
			'r'  => s.push_char('\r'),
			'e'  => s.push_char('\x1b'),
			'x' => {
				let c = chars.next().ok_or(StrEscapeError::HexEof)?;
				let n1 = c.to_digit(16).ok_or(StrEscapeError::InvalidHex(c))?;
				let c = chars.next().ok_or(StrEscapeError::HexEof)?;
				let n2 = c.to_digit(16).ok_or(StrEscapeError::InvalidHex(c))?;
				s.push_byte((n1 * 16 + n2) as u8);
			},
			'u' => {
				let Some('{') = chars.next() else {
					return Err(StrEscapeError::MissingBrace)
				};
				let mut n = 0_u32;
				loop {
					let Some(c) = chars.next() else {
						return Err(StrEscapeError::UnicodeEof)
					};
					if c == '}' { break }
					if n > 0x10ffff {
						return Err(StrEscapeError::CodepointTooLarge)
					}
					n = n * 16 + c.to_digit(16).ok_or(StrEscapeError::InvalidHex(c))?;
				}
				let ch = char::from_u32(n).ok_or(StrEscapeError::InvalidCodepoint(n))?;
				s.push_char(ch);

			},
			c => return Err(StrEscapeError::Invalid(c)),
		}
	}

	Ok(s)
}

pub fn parse_float<'a, S: Into<&'a LStr>>(f: S) -> Result<f64, ParseFloatError> {
	let mut s = String::new();
	for c in f.into().chars() {
		if c != '_' {
			s.push(c);
		}
	}
	s.parse()
}

pub fn parse_int<'a, S: Into<&'a LStr>>(f: S, radix: u32) -> Result<i64, ParseIntError> {
	let mut s = String::new();
	for c in f.into().chars() {
		if c != '_' {
			s.push(c);
		}
	}
	i64::from_str_radix(&s, radix)
}

pub fn parse_int_literal<'a, S: Into<&'a LStr>>(f: S) -> Result<i64, ParseIntError> {
    let f = f.into();
    match f.chars().nth(2) {
        Some('x') => parse_int(&f[2..], 16),
        Some('o') => parse_int(&f[2..], 8),
        Some('s') => parse_int(&f[2..], 6),
        Some('b') => parse_int(&f[2..], 2),
        _ => parse_int(f, 10),
    }
}