aimx/literals/

literal.rs

//! Literal value parsing and conversion for AIMX expressions.
//!
//! Provides the [`Literal`] enum and helpers to parse and convert booleans,
//! numbers, text, dates, and tasks used by the expression engine.
//! Key entry points: [`parse_literal`], [`parse_bool`], [`parse_task`].

use crate::{
    aim::{Typedef, WriterLike, Writer},
    literals::{parse_date, parse_number, parse_text},
};
use anyhow::{Result, anyhow};
use jiff::civil::DateTime;
use nom::{
    IResult, Parser,
    branch::alt,
    bytes::complete::tag,
    character::complete::{char, multispace0},
    combinator::{map, opt, value}, sequence::delimited,
};
use std::cmp::Ordering;
use std::{
    fmt,
    sync::Arc,
};

/// Literal values supported by AIMX expressions.
///
/// Provides the core literal variants and helpers used by the expression
/// engine for parsing, type checking, comparison, and conversion.
#[derive(Debug, Clone, PartialEq)]
pub enum Literal {
    /// Empty or untyped literal.
    Empty,
    /// Boolean value.
    Bool(bool),
    /// Date/time value.
    Date(DateTime),
    /// 64-bit floating point number.
    Number(f64),
    /// Task with optional status and description.
    /// Status semantics: Some(true)=completed, Some(false)=failed, None=pending.
    Task(Option<bool>, Arc<str>),
    /// UTF-8 string value.
    Text(Arc<str>),
}

impl Literal {
    /// Check if this literal matches the specified type.
    ///
    /// # Arguments
    ///
    /// * `typedef` - The type definition to check against
    ///
    /// # Returns
    ///
    /// Returns `true` if this literal matches the specified type, `false` otherwise.
    pub fn is_type(&self, typedef: &Typedef) -> bool {
        match self {
            Literal::Empty => false,
            Literal::Bool(_) => typedef.is_bool() | typedef.is_any(),
            Literal::Date(_) => typedef.is_date() | typedef.is_any(),
            Literal::Number(_) => typedef.is_number() | typedef.is_any(),
            Literal::Task(..) => typedef.is_task() | typedef.is_any(),
            Literal::Text(_) => typedef.is_text() | typedef.is_any(),
        }
    }

    /// Get the type of this literal.
    ///
    /// # Returns
    ///
    /// Returns a `Result<Typedef>` containing the type of this literal,
    /// or an error if this is an Empty literal.
    pub fn get_type(&self) -> Result<Typedef> {
        match self {
            Literal::Empty => Err(anyhow!("Expecting type, found Empty")),
            Literal::Bool(_) => Ok(Typedef::Bool),
            Literal::Date(_) => Ok(Typedef::Date),
            Literal::Number(_) => Ok(Typedef::Number),
            Literal::Task(..) => Ok(Typedef::Task),
            Literal::Text(_) => Ok(Typedef::Text),
        }
    }

    /// Convert this literal to match the type of another literal.
    ///
    /// This method performs type conversion according to the grammar's
    /// type promotion rules, converting this literal to match the type
    /// of the provided reference literal.
    ///
    /// # Arguments
    ///
    /// * `literal` - The reference literal whose type determines the conversion
    ///
    /// # Returns
    ///
    /// Returns a `Result<Literal>` containing the converted literal or an error
    /// if conversion is not possible.
    pub fn as_type(self, literal: &Literal) -> Result<Literal> {
        match literal {
            Literal::Empty => Err(anyhow!(
                "Expecting type as {}, found Empty",
                literal.type_as_string()
            )),
            Literal::Bool(_) => Ok(self.as_bool()),
            Literal::Date(_) => self.as_date(),
            Literal::Number(_) => self.as_number(),
            Literal::Task(..) => self.as_task(),
            Literal::Text(_) => self.as_text(),
        }
    }

    pub fn to_type(self, typedef: &Typedef) -> Result<Literal> {
        match typedef {
            Typedef::Any => Ok(self),
            Typedef::Bool => Ok(self.as_bool()),
            Typedef::Date => self.as_date(),
            Typedef::Number => self.as_number(),
            Typedef::Task => self.as_task(),
            Typedef::Text => self.as_text(),
            _ => Err(anyhow!("Expecting literal type, found {}", typedef)),
        }
    }

    /// Check if this literal is empty.
    pub fn is_empty(&self) -> bool {
        matches!(self, Literal::Empty)
    }

    /// Check if this literal represents a boolean value.
    pub fn is_bool(&self) -> bool {
        matches!(self, Literal::Bool(_))
    }

    /// Create a boolean literal from a boolean value.
    pub fn from_bool(b: bool) -> Self {
        Literal::Bool(b)
    }

    /// Convert this literal to a boolean representation.
    ///
    /// Performs type conversion to boolean according to the grammar's
    /// truthiness rules:
    /// - Numbers: 0 is false, non-zero is true
    /// - Text: Empty string is false, non-empty is true
    /// - Dates: Always true (they exist)
    /// - Tasks: Status determines value, no status is false
    ///
    /// This function provides an implicit error free conversion from any
    /// literal to bool specifically for the conditional ternary operator
    /// making a type safe error free check possible.
    ///
    /// e.g. `user.birthday ? user.birthday : _`
    pub fn as_bool(self) -> Literal {
        match self {
            Literal::Empty => Literal::Bool(false),
            Literal::Bool(_) => self,
            Literal::Date(_) => {
                // Check for non-zero days
                if let Ok(number) = self.as_number() {
                    number.as_bool()
                } else {
                    Literal::Bool(false)
                }
            }
            Literal::Number(number) => Literal::Bool(number != 0.0),
            Literal::Task(status, _) => match status {
                Some(state) => Literal::Bool(state),
                None => Literal::Bool(false),
            },
            Literal::Text(text) => Literal::Bool(!text.is_empty()),
        }
    }

    /// Extract a boolean value from this literal.
    ///
    /// This is a convenience method for when you specifically need a `bool` value.
    pub fn to_bool(&self) -> bool {
        match self {
            Literal::Empty => false,
            Literal::Bool(b) => *b,
            Literal::Date(_) => {
                // Check for non-zero days
                if let Ok(number) = self.to_number() {
                    number != 0.0
                } else {
                    false
                }
            }
            Literal::Number(number) => *number != 0.0,
            Literal::Task(status, _) => (*status).unwrap_or_default(),
            Literal::Text(text) => !text.is_empty(),
        }
    }

    /// Check if this literal represents a date value.
    pub fn is_date(&self) -> bool {
        matches!(self, Literal::Date(_))
    }

    /// Create a date literal from a DateTime value.
    pub fn from_date(d: DateTime) -> Self {
        Literal::Date(d)
    }

    /// Convert this literal to a date representation.
    ///
    /// Attempts to convert the literal to a date according to the grammar's
    /// conversion rules:
    /// - Boolean: true becomes Unix epoch + 1 second, false becomes Unix epoch
    /// - Number: Interpreted as Unix timestamp
    /// - Text: Parsed as date if possible
    /// - Task: Text component parsed as date if possible
    pub fn as_date(self) -> Result<Literal> {
        match self {
            Literal::Empty => Err(anyhow!("Expecting type as Date, found Empty")),
            Literal::Bool(state) => {
                // Convert boolean to timestamp: true = 1, false = 0
                let timestamp = if state { 1i64 } else { 0i64 };
                match DateTime::new(1970, 1, 1, 0, 0, 0, 0) {
                    Ok(epoch) => {
                        // Add the timestamp seconds to the epoch
                        match jiff::Span::new().try_seconds(timestamp) {
                            Ok(duration) => match epoch.checked_add(duration) {
                                Ok(new_dt) => Ok(Literal::Date(new_dt)),
                                Err(_) => Ok(Literal::Date(epoch)),
                            },
                            Err(_) => Ok(Literal::Date(epoch)),
                        }
                    }
                    Err(_) => Err(anyhow!("Failed to create Date from Bool")),
                }
            }
            Literal::Date(_) => Ok(self),
            Literal::Number(number) => {
                // Convert number to timestamp (assuming it's a Unix timestamp)
                let timestamp = number as i64;
                match DateTime::new(1970, 1, 1, 0, 0, 0, 0) {
                    Ok(epoch) => {
                        // Add the timestamp seconds to the epoch
                        match jiff::Span::new().try_seconds(timestamp) {
                            Ok(duration) => match epoch.checked_add(duration) {
                                Ok(new_dt) => Ok(Literal::Date(new_dt)),
                                Err(_) => {
                                    Err(anyhow!("Failed to create Date from Number({})", number))
                                }
                            },
                            Err(_) => Err(anyhow!("Failed to create Date from Number({})", number)),
                        }
                    }
                    Err(_) => Err(anyhow!("Failed to create Date from Number({})", number)),
                }
            }
            Literal::Task(_, text) => {
                // Try to parse the task text as a date
                match parse_date(&text) {
                    Ok((_, date)) => Ok(Literal::Date(date)),
                    Err(_) => Err(anyhow!("Failed to parse Task text as Date")),
                }
            }
            Literal::Text(text) => {
                // Try to parse the text as a date
                match parse_date(&text) {
                    Ok((_, date)) => Ok(Literal::Date(date)),
                    Err(_) => Err(anyhow!("Failed to parse Text({}) as Date", text)),
                }
            }
        }
    }

    /// Check if this literal represents a number value.
    pub fn is_number(&self) -> bool {
        matches!(self, Literal::Number(_))
    }

    /// Create a number literal from an f64 value.
    pub fn from_number(n: f64) -> Self {
        Literal::Number(n)
    }

    /// Convert this literal to a number representation.
    ///
    /// Attempts to convert the literal to a number according to the grammar's
    /// conversion rules:
    /// - Boolean: false becomes 0, true becomes 1
    /// - Date: Converted to Unix timestamp
    /// - Text: Parsed as number if it represents a valid numeric literal
    /// - Task: Status determines value (true=1, false=-1, none=0)
    pub fn as_number(self) -> Result<Literal> {
        match self {
            Literal::Empty => Err(anyhow!("Expecting type as Number, found Empty")),
            Literal::Bool(state) => Ok(Literal::Number(if state { 1.0 } else { 0.0 })),
            Literal::Date(dt) => {
                if let Ok(utc_dt) = dt.to_zoned(jiff::tz::TimeZone::UTC) {
                    let seconds = utc_dt.timestamp().as_second();
                    Ok(Literal::Number(seconds as f64))
                } else {
                    Ok(Literal::Number(0.0))
                }
            }
            Literal::Number(_) => Ok(self),
            Literal::Task(status, _) => match status {
                Some(state) => Ok(Literal::Number(if state { 1.0 } else { -1.0 })),
                None => Ok(Literal::Number(0.0)),
            },
            Literal::Text(text) => match text.parse::<f64>() {
                Ok(number) => Ok(Literal::Number(number)),
                Err(_) => Err(anyhow!("Expecting Text as Number, found \"{}\"", text)),
            },
        }
    }

    /// Extract a numeric value from this literal.
    ///
    /// This is a convenience method for when you specifically need a `f64` number.
    pub fn to_number(&self) -> Result<f64> {
        match self {
            Literal::Empty => Err(anyhow!("Expecting type as Number, found Empty")),
            Literal::Bool(state) => Ok(if *state { 1.0 } else { 0.0 }),
            Literal::Date(dt) => {
                if let Ok(utc_dt) = dt.to_zoned(jiff::tz::TimeZone::UTC) {
                    let seconds = utc_dt.timestamp().as_second();
                    Ok(seconds as f64)
                } else {
                    Ok(0.0)
                }
            }
            Literal::Number(number) => Ok(*number),
            Literal::Task(status, _) => match *status {
                Some(state) => Ok(if state { 1.0 } else { -1.0 }),
                None => Ok(0.0),
            },
            Literal::Text(text) => match text.parse::<f64>() {
                Ok(number) => Ok(number),
                Err(_) => Err(anyhow!("Expecting Text as Number, found \"{}\"", text)),
            },
        }
    }

    /// Check if this literal represents a task value.
    pub fn is_task(&self) -> bool {
        matches!(self, Literal::Task(..))
    }

    /// Create a task literal from status and text.
    pub fn from_task(status: Option<bool>, task: Arc<str>) -> Self {
        Literal::Task(status, task)
    }

    /// Convert this literal to a task representation.
    ///
    /// Converts the literal to a task according to the grammar's conversion rules:
    /// - Boolean: Status becomes the boolean value, text becomes "true"/"false"
    /// - Date: No status, text becomes date string
    /// - Number: Status based on sign (positive=true, negative=false, zero=none), text becomes number string
    /// - Text: No status, text remains the same
    pub fn as_task(self) -> Result<Literal> {
        match self {
            Literal::Empty => Err(anyhow!("Expecting type as Task, found Empty")),
            Literal::Bool(state) => Ok(Literal::Task(Some(state), Arc::from(state.to_string()))),
            Literal::Date(dt) => Ok(Literal::Task(None, Arc::from(dt.to_string()))),
            Literal::Number(number) => {
                let status = if number > 0.0 {
                    Some(true)
                } else if number < 0.0 {
                    Some(false)
                } else {
                    None
                };
                Ok(Literal::Task(status, Arc::from(number.to_string())))
            }
            Literal::Task(..) => Ok(self),
            Literal::Text(text) => Ok(Literal::Task(None, text)),
        }
    }

    /// Check if this literal represents a text value.
    pub fn is_text(&self) -> bool {
        matches!(self, Literal::Text(_))
    }

    /// Create a text literal from a String.
    pub fn from_text(text: Arc<str>) -> Self {
        Literal::Text(text)
    }

    /// Convert this literal to a text representation.
    ///
    /// Converts the literal to text according to the grammar's conversion rules:
    /// - Boolean: "true" or "false"
    /// - Date: Formatted as date string
    /// - Number: Formatted as string
    /// - Task: Text component of the task
    pub fn as_text(self) -> Result<Literal> {
        match self {
            Literal::Empty => Err(anyhow!("Expecting type as Text, found Empty")),
            Literal::Bool(state) => Ok(Literal::Text(Arc::from(state.to_string()))),
            Literal::Date(dt) => Ok(Literal::Text(Arc::from(dt.to_string()))),
            Literal::Number(number) => Ok(Literal::Text(Arc::from(number.to_string()))),
            Literal::Task(_, text) => Ok(Literal::Text(text)),
            Literal::Text(_) => Ok(self),
        }
    }

    /// Get a string representation of this literal's type.
    pub fn type_as_string(&self) -> &'static str {
        match self {
            Literal::Empty => "Empty",
            Literal::Bool(_) => "Bool",
            Literal::Date(_) => "Date",
            Literal::Number(_) => "Number",
            Literal::Task(..) => "Task",
            Literal::Text(_) => "Text",
        }
    }

    // Helper function to get type order for consistent sorting
    fn type_order(&self) -> u8 {
        match self {
            Literal::Empty => 0,
            Literal::Bool(_) => 1,
            Literal::Number(_) => 2,
            Literal::Date(_) => 3,
            Literal::Text(_) => 4,
            Literal::Task(..) => 5,
        }
    }

    fn type_promote(self, literal: &Literal) -> Result<Literal> {
        match literal {
            Literal::Task(..) => {
                match self {
                    Literal::Text(t) => Ok(Literal::Task(None, t)),
                    Literal::Date(dt) => Ok(Literal::Task(None, Arc::from(dt.to_string()))),
                    Literal::Number(n) => Ok(Literal::Task(None, Arc::from(n.to_string()))),
                    //Literal::Bool(b) => Ok(Literal::Task(Some(b), "".to_owned())),
                    _ => Err(anyhow!("Type promote to Task failed")),
                }
            }
            Literal::Text(_) => {
                match self {
                    Literal::Date(dt) => Ok(Literal::Text(Arc::from(dt.to_string()))),
                    Literal::Number(n) => Ok(Literal::Text(Arc::from(n.to_string()))),
                    //Literal::Bool(b) => Ok(Literal::Text(b.to_string())),
                    _ => Err(anyhow!("Type promote to Text failed")),
                }
            }
            Literal::Date(_) => {
                match self {
                    Literal::Number(number) => {
                        // Convert number to timestamp (assuming it's a Unix timestamp)
                        let timestamp = number as i64;
                        match DateTime::new(1970, 1, 1, 0, 0, 0, 0) {
                            Ok(epoch) => {
                                // Add the timestamp seconds to the epoch
                                match jiff::Span::new().try_seconds(timestamp) {
                                    Ok(duration) => match epoch.checked_add(duration) {
                                        Ok(new_dt) => Ok(Literal::Date(new_dt)),
                                        Err(_) => Err(anyhow!(
                                            "Failed to create Date from Number({})",
                                            number
                                        )),
                                    },
                                    Err(_) => Err(anyhow!(
                                        "Failed to create Date from Number({})",
                                        number
                                    )),
                                }
                            }
                            Err(_) => Err(anyhow!("Failed to create Date from Number({})", number)),
                        }
                    }
                    _ => Err(anyhow!("Type promote to Date failed")),
                }
            }
            Literal::Number(_) => match self {
                Literal::Bool(b) => Ok(Literal::Number(if b { 1.0 } else { 0.0 })),
                _ => Err(anyhow!("Type promote to Task failed")),
            },
            _ => Err(anyhow!("Type promote failed")),
        }
    }

    pub fn print(&self, writer: &mut Writer) {
        match self {
            Literal::Bool(b) => writer.write_bool(*b),
            Literal::Date(d) => writer.write_date(d),
            Literal::Empty => {}
            Literal::Number(n) => writer.write_f64(*n),
            Literal::Task(status, text) => {
                match status {
                    Some(check) => writer.write_str(if *check { "[x] " } else { "[-] " }),
                    None => writer.write_str("[ ] "),
                }
                writer.print(text);
            },
            Literal::Text(text) => writer.print(text),
        }
    }

    /// Return the formula-string representation (round-trippable by the parser).
    pub fn to_formula(&self) -> String {
        let mut writer = Writer::formulizer();
        self.print(&mut writer);
        writer.finish()
    }
}

impl WriterLike for Literal {
    fn write(&self, writer: &mut Writer) {
        self.print(writer);
    }
}

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

impl PartialOrd for Literal {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        // Check for special cases
        match (self, other) {
            (Literal::Text(t), Literal::Bool(b)) => {
                if let Ok(a) = t.parse::<bool>() { return a.partial_cmp(b) }
            },
            (Literal::Bool(a), Literal::Text(t)) => {
                if let Ok(b) = t.parse::<bool>() { return a.partial_cmp(&b) }
            },
            (Literal::Text(t), Literal::Number(b)) => {
                if let Ok(a) = t.parse::<f64>() { return a.partial_cmp(b) }
            },
            (Literal::Number(a), Literal::Text(t)) => {
                if let Ok(b) = t.parse::<f64>() { return a.partial_cmp(&b) }
            }
            (Literal::Text(t), Literal::Empty) | (Literal::Empty, Literal::Text(t)) => {
                if t.is_empty() {
                    return Some(Ordering::Equal);
                }
            }
            _ => {}
        }
        // Define a consistent ordering by type first, then value
        // Type ordering: Empty < Bool < Number < Date < Task < Text
        let self_type_order = self.type_order();
        let other_type_order = other.type_order();

        if self_type_order > other_type_order {
            match other.clone().type_promote(self) {
                Ok(that) => self.partial_cmp(&that),
                _ => Some(Ordering::Greater),
            }
        } else if self_type_order < other_type_order {
            match self.clone().type_promote(other) {
                Ok(this) => this.partial_cmp(other),
                _ => Some(Ordering::Less),
            }
        } else {
            // Same type, compare values
            match (self, other) {
                (Literal::Empty, Literal::Empty) => Some(Ordering::Equal),
                (Literal::Bool(a), Literal::Bool(b)) => a.partial_cmp(b),
                (Literal::Date(a), Literal::Date(b)) => a.partial_cmp(b),
                (Literal::Number(a), Literal::Number(b)) => a.partial_cmp(b),
                (Literal::Task(status1, text1), Literal::Task(status2, text2)) => {
                    // Order by status first: Some(true) > None > Some(false)
                    match (status1, status2) {
                        (Some(true), Some(false)) => Some(Ordering::Greater),
                        (Some(true), None) => Some(Ordering::Greater),
                        (None, Some(true)) => Some(Ordering::Less),
                        (None, Some(false)) => Some(Ordering::Greater),
                        (Some(false), Some(true)) => Some(Ordering::Less),
                        (Some(false), None) => Some(Ordering::Less),
                        // Same status types or both None, compare texts
                        (Some(true), Some(true)) | (Some(false), Some(false)) | (None, None) => {
                            text1.partial_cmp(text2)
                        }
                    }
                }
                (Literal::Text(a), Literal::Text(b)) => a.partial_cmp(b),
                _ => Some(Ordering::Equal), // This shouldn't happen due to type ordering check above
            }
        }
    }
}

impl Eq for Literal {}

impl Ord for Literal {
    fn cmp(&self, other: &Self) -> Ordering {
        // Use partial_cmp, but provide a fallback for None cases
        self.partial_cmp(other).unwrap_or(Ordering::Equal)
    }
}

/// Parse a literal value from input according to AIMX literal rules.
///
/// Tries boolean, date, number, task, then text, trimming surrounding
/// whitespace.
pub fn parse_literal(input: &str) -> IResult<&str, Literal> {
    delimited(
        multispace0,
        alt((
            map(parse_bool, Literal::Bool),
            map(parse_date, Literal::Date),
            map(parse_number, Literal::Number),
            map(parse_task, |(status, text)| Literal::Task(status, text)),
            map(parse_text, Literal::Text),
        )),
        multispace0
    ).parse(input)
}


/// Parse a boolean literal: `true` or `false`.
///
/// Exact, case-sensitive match; no numeric or fuzzy forms.
pub fn parse_bool(input: &str) -> IResult<&str, bool> {
    alt((map(tag("true"), |_| true), map(tag("false"), |_| false))).parse(input)
}

/// Parse a task literal: `[status] description`.
///
/// Status is `+` (Some(true)), `-` (Some(false)), or omitted/space (None).
/// Description is parsed via [`parse_text`].
pub fn parse_task(input: &str) -> IResult<&str, (Option<bool>, Arc<str>)> {
    (
        delimited(
            char('['),
            delimited(
                multispace0,
                opt(alt((
                    value(true, char('+')),
                    value(false, char('-')),
                ))),
                multispace0,
            ),
            char(']'),
        ),
        multispace0,
        parse_text,
    ).parse(input)
    .map(|(input, (status, _, text))| (input, (status, text)))
}