use std::{fmt, str::FromStr};

use crate::{
    Buffer, ParseError,
    err::{perr, ParseErrorKind::*},
    parse::{end_dec_digits, first_byte_or_empty, check_suffix},
};



/// A floating point literal, e.g. `3.14`, `8.`, `135e12`, or `1.956e2f64`.
///
/// This kind of literal has several forms, but generally consists of a main
/// number part, an optional exponent and an optional type suffix. See
/// [the reference][ref] for more information.
///
/// A leading minus sign `-` is not part of the literal grammar! `-3.14` are two
/// tokens in the Rust grammar. Further, `27` and `27f32` are both not float,
/// but integer literals! Consequently `FloatLit::parse` will reject them.
///
///
/// [ref]: https://doc.rust-lang.org/reference/tokens.html#floating-point-literals
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FloatLit<B: Buffer> {
    /// The whole raw input. The `usize` fields in this struct partition this
    /// string. Always true: `end_integer_part <= end_fractional_part`.
    ///
    /// ```text
    ///    12_3.4_56e789f32
    ///        ╷    ╷   ╷
    ///        |    |   └ end_number_part = 13
    ///        |    └ end_fractional_part = 9
    ///        └ end_integer_part = 4
    ///
    ///    246.
    ///       ╷╷
    ///       |└ end_fractional_part = end_number_part = 4
    ///       └ end_integer_part = 3
    ///
    ///    1234e89
    ///        ╷  ╷
    ///        |  └ end_number_part = 7
    ///        └ end_integer_part = end_fractional_part = 4
    /// ```
    raw: B,

    /// The first index not part of the integer part anymore. Since the integer
    /// part is at the start, this is also the length of that part.
    end_integer_part: usize,

    /// The first index after the fractional part.
    end_fractional_part: usize,

    /// The first index after the whole number part (everything except type suffix).
    end_number_part: usize,
}

impl<B: Buffer> FloatLit<B> {
    /// Parses the input as a floating point literal. Returns an error if the
    /// input is invalid or represents a different kind of literal. Will also
    /// reject decimal integer literals like `23` or `17f32`, in accordance
    /// with the spec.
    pub fn parse(s: B) -> Result<Self, ParseError> {
        match first_byte_or_empty(&s)? {
            b'0'..=b'9' => {
                // TODO: simplify once RFC 2528 is stabilized
                let FloatLit {
                    end_integer_part,
                    end_fractional_part,
                    end_number_part,
                    ..
                } = parse_impl(&s)?;

                Ok(Self { raw: s, end_integer_part, end_fractional_part, end_number_part })
            },
            _ => Err(perr(0, DoesNotStartWithDigit)),
        }
    }

    /// Returns the number part (including integer part, fractional part and
    /// exponent), but without the suffix. If you want an actual floating
    /// point value, you need to parse this string, e.g. with `f32::from_str`
    /// or an external crate.
    pub fn number_part(&self) -> &str {
        &(*self.raw)[..self.end_number_part]
    }

    /// Returns the non-empty integer part of this literal.
    pub fn integer_part(&self) -> &str {
        &(*self.raw)[..self.end_integer_part]
    }

    /// Returns the optional fractional part of this literal. Does not include
    /// the period. If a period exists in the input, `Some` is returned, `None`
    /// otherwise. Note that `Some("")` might be returned, e.g. for `3.`.
    pub fn fractional_part(&self) -> Option<&str> {
        if self.end_integer_part == self.end_fractional_part {
            None
        } else {
            Some(&(*self.raw)[self.end_integer_part + 1..self.end_fractional_part])
        }
    }

    /// Optional exponent part. Might be empty if there was no exponent part in
    /// the input. Includes the `e` or `E` at the beginning.
    pub fn exponent_part(&self) -> &str {
        &(*self.raw)[self.end_fractional_part..self.end_number_part]
    }

    /// The optional suffix. Returns `""` if the suffix is empty/does not exist.
    pub fn suffix(&self) -> &str {
        &(*self.raw)[self.end_number_part..]
    }

    /// Returns the raw input that was passed to `parse`.
    pub fn raw_input(&self) -> &str {
        &self.raw
    }

    /// Returns the raw input that was passed to `parse`, potentially owned.
    pub fn into_raw_input(self) -> B {
        self.raw
    }
}

impl FloatLit<&str> {
    /// Makes a copy of the underlying buffer and returns the owned version of
    /// `Self`.
    pub fn to_owned(&self) -> FloatLit<String> {
        FloatLit {
            raw: self.raw.to_owned(),
            end_integer_part: self.end_integer_part,
            end_fractional_part: self.end_fractional_part,
            end_number_part: self.end_number_part,
        }
    }
}

impl<B: Buffer> fmt::Display for FloatLit<B> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", &*self.raw)
    }
}

/// Precondition: first byte of string has to be in `b'0'..=b'9'`.
#[inline(never)]
pub(crate) fn parse_impl(input: &str) -> Result<FloatLit<&str>, ParseError> {
    // Integer part.
    let end_integer_part = end_dec_digits(input.as_bytes());
    let rest = &input[end_integer_part..];


    // Fractional part.
    let end_fractional_part = if rest.as_bytes().get(0) == Some(&b'.') {
        // The fractional part must not start with `_`.
        if rest.as_bytes().get(1) == Some(&b'_') {
            return Err(perr(end_integer_part + 1, UnexpectedChar));
        }

        end_dec_digits(rest[1..].as_bytes()) + 1 + end_integer_part
    } else {
        end_integer_part
    };
    let rest = &input[end_fractional_part..];

    // If we have a period that is not followed by decimal digits, the
    // literal must end now.
    if end_integer_part + 1 == end_fractional_part && !rest.is_empty() {
        return Err(perr(end_integer_part + 1, UnexpectedChar));
    }

    // Optional exponent.
    let end_number_part = if rest.starts_with('e') || rest.starts_with('E') {
        // Strip single - or + sign at the beginning.
        let exp_number_start = match rest.as_bytes().get(1) {
            Some(b'-') | Some(b'+') => 2,
            _ => 1,
        };

        // Find end of exponent and make sure there is at least one digit.
        let end_exponent = end_dec_digits(rest[exp_number_start..].as_bytes()) + exp_number_start;
        if !rest[exp_number_start..end_exponent].bytes().any(|b| matches!(b, b'0'..=b'9')) {
            return Err(perr(
                end_fractional_part..end_fractional_part + end_exponent,
                NoExponentDigits,
            ));
        }

        end_exponent + end_fractional_part
    } else {
        end_fractional_part
    };

    // Make sure the suffix is valid.
    let suffix = &input[end_number_part..];
    check_suffix(suffix).map_err(|kind| perr(end_number_part..input.len(), kind))?;

    // A float literal needs either a fractional or exponent part, otherwise its
    // an integer literal.
    if end_integer_part == end_number_part {
        return Err(perr(None, UnexpectedIntegerLit));
    }

    Ok(FloatLit {
        raw: input,
        end_integer_part,
        end_fractional_part,
        end_number_part,
    })
}


/// All possible float type suffixes.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum FloatType {
    F32,
    F64,
}

impl FloatType {
    /// Returns the type corresponding to the given suffix (e.g. `"f32"` is
    /// mapped to `Self::F32`). If the suffix is not a valid float type, `None`
    /// is returned.
    pub fn from_suffix(suffix: &str) -> Option<Self> {
        match suffix {
            "f32" => Some(FloatType::F32),
            "f64" => Some(FloatType::F64),
            _ => None,
        }
    }

    /// Returns the suffix for this type, e.g. `"f32"` for `Self::F32`.
    pub fn suffix(self) -> &'static str {
        match self {
            Self::F32 => "f32",
            Self::F64 => "f64",
        }
    }
}

impl FromStr for FloatType {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::from_suffix(s).ok_or(())
    }
}

impl fmt::Display for FloatType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.suffix().fmt(f)
    }
}


#[cfg(test)]
mod tests;