bliplib 0.2.5

#![allow(dead_code)]

use std::{
    error::Error,
    fmt::Debug,
    fs::File,
    io::{self, Cursor, Read, stdin},
    ops::Not,
    str::FromStr,
};

use anyhow::anyhow;
use bliplib::compiler::Expression;
use clap::Parser;
use derive_wrapper::AsRef;
use getset::Getters;
use hound::SampleFormat;
use mp3lame_encoder::{Bitrate, Quality};
use nom::{
    Finish, Parser as P,
    branch::alt,
    bytes::complete::tag,
    character::complete::{char, u16, usize},
    combinator::{rest, success, value},
    error::ErrorKind,
    sequence::preceded,
};
use nom_locate::{LocatedSpan, position};
use strum::{EnumDiscriminants, EnumIter, EnumString, IntoDiscriminant, IntoStaticStr};
use thiserror::Error;

const DEFAULT_INSTRUMENT: &str = "sin(2*pi()*(442*2^((n+1)/N))*t)";
const DEFAULT_LENGTH: &str = "2^(2-log(2, l))*(60/T)";

#[derive(Debug, Parser)]
#[command(version, author, about)]
pub(super) enum Cli {
    /// Play a song
    Play(PlayOpts),
    /// Check for typos
    Check(PlayOpts),
    /// Export a song to an audio file or stdout
    Export(ExportOpts),
    /// Memo menu for examples and general help about syntax and supported audio formats
    #[command(subcommand)]
    Memo(MemoKind),
}

#[derive(Debug, Parser, Clone, Getters)]
#[getset(get = "pub(super)")]
pub(super) struct PlayOpts {
    /// Use this sheet music [default: stdin]
    #[command(flatten)]
    input: InputGroup<false>,
    /// Set available notes ("a,b,c" for example)
    #[arg(short, long, value_delimiter = ',')]
    notes: Vec<String>,
    /// Set the signal expression (instrument) used to generate music samples
    #[arg(short, long, default_value = DEFAULT_INSTRUMENT)]
    instrument: Expression,
    /// Set the expression used to generate note lengths in seconds
    #[arg(short, long, default_value = DEFAULT_LENGTH)]
    length: Expression,
    /// Add a variable named VARIABLE (a single letter) and set its initial value to VALUE
    #[arg(short, long = "variable", value_name = "VARIABLE=VALUE", value_parser = parse_key_val::<'=', Letter, f64>)]
    #[getset(skip)]
    variables: Vec<(Letter, f64)>,
    /// Add a macro named NAME (single character, not alphanumeric) which expands to EXPANSION when called in sheet music
    #[arg(short, long = "macro", value_name = "NAME:EXPANSION", value_parser = parse_key_val::<':', NotALetter, String>)]
    #[getset(skip)]
    macros: Vec<(NotALetter, String)>,
    /// Add a slope expression named NAME which mutates the VARIABLE with the result of EXPR each frame
    #[arg(short, long = "slope", value_name = "NAME:VARIABLE=EXPR", value_parser = parse_key_tuple::<LetterString, Letter, Expression>)]
    #[getset(skip)]
    slopes: Vec<(LetterString, (Letter, Expression))>,
}

impl PlayOpts {
    pub(super) fn variables(&self) -> impl Iterator<Item = (&char, &f64)> {
        self.variables.iter().map(|(c, f)| (c.as_ref(), f))
    }

    pub(super) fn macros(&self) -> impl Iterator<Item = (&char, &String)> {
        self.macros.iter().map(|(c, s)| (c.as_ref(), s))
    }

    pub(super) fn slopes(&self) -> impl Iterator<Item = (&String, (&char, &Expression))> {
        self.slopes
            .iter()
            .map(|(name, (v, e))| (name.as_ref(), (v.as_ref(), e)))
    }
}

impl<const CREATE_IF_NOT_EXISTS: bool> InputGroup<CREATE_IF_NOT_EXISTS>
where
    Self: Clone,
{
    pub(super) fn get(&self) -> Box<dyn Read> {
        self.input
            .as_ref()
            .map(|i| Box::new(i.clone().0) as Box<dyn Read>)
            .or(self
                .sheet_music_string
                .as_ref()
                .map(|s| Box::new(Cursor::new(s.clone())) as Box<dyn Read>))
            .unwrap_or(Box::new(stdin()))
    }
}

#[derive(Debug, Clone, Copy, AsRef)]
struct Letter(char);

#[derive(Debug, Error)]
enum LetterError {
    #[error("the character '{0}' should be a letter")]
    Char(char),
    #[error("no characters found")]
    Empty,
}

impl FromStr for Letter {
    type Err = LetterError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let c = s.chars().next().ok_or(Self::Err::Empty)?;
        c.is_alphabetic()
            .then_some(c)
            .map(Self)
            .ok_or(Self::Err::Char(c))
    }
}

#[derive(Debug, Clone, Copy, AsRef)]
struct NotALetter(char);

#[derive(Debug, Error)]
enum NotALetterError {
    #[error("the character '{0}' should not be a letter")]
    Char(char),
    #[error("no characters found")]
    Empty,
}

impl FromStr for NotALetter {
    type Err = NotALetterError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let c = s.chars().next().ok_or(Self::Err::Empty)?;
        c.is_alphabetic()
            .not()
            .then_some(c)
            .map(Self)
            .ok_or(Self::Err::Char(c))
    }
}

#[derive(Debug, Clone, AsRef)]
struct LetterString(String);

#[derive(Debug, Error)]
enum LetterStringError {
    #[error("the string \"{0}\" should be only letters")]
    String(String),
    #[error("no characters found")]
    Empty,
}

impl FromStr for LetterString {
    type Err = LetterStringError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        s.is_empty()
            .not()
            .then_some(
                s.chars()
                    .all(|c| c.is_alphabetic())
                    .then_some(s)
                    .map(str::to_string)
                    .map(Self)
                    .ok_or(Self::Err::String(s.to_string())),
            )
            .ok_or(Self::Err::Empty)?
    }
}

/// Parse a single key-value pair
///
/// From https://github.com/clap-rs/clap/blob/6b12a81bafe7b9d013b06981f520ab4c70da5510/examples/typed-derive.rs
fn parse_key_val<const SEP: char, T, U>(
    s: &str,
) -> Result<(T, U), Box<dyn Error + Send + Sync + 'static>>
where
    T: std::str::FromStr,
    T::Err: Error + Send + Sync + 'static,
    U: std::str::FromStr,
    U::Err: Error + Send + Sync + 'static,
{
    let pos = s
        .find(SEP)
        .ok_or_else(|| format!("invalid KEY{SEP}value: no `{SEP}` found in `{s}`"))?;
    Ok((s[..pos].parse()?, s[pos + 1..].parse()?))
}

fn parse_key_tuple<T, U1, U2>(
    s: &str,
) -> Result<(T, (U1, U2)), Box<dyn Error + Send + Sync + 'static>>
where
    T: std::str::FromStr,
    T::Err: Error + Send + Sync + 'static,
    U1: std::str::FromStr,
    U1::Err: Error + Send + Sync + 'static,
    U2: std::str::FromStr,
    U2::Err: Error + Send + Sync + 'static,
{
    let pos = s
        .find(':')
        .ok_or_else(|| format!("invalid KEY:value, no `:` found in `{s}`"))?;
    Ok((
        s[..pos].parse()?,
        parse_key_val::<'=', _, _>(&s[pos + 1..])?,
    ))
}

#[derive(Debug, Parser, Clone)]
#[group(required = false, multiple = false)]
pub(super) struct InputGroup<const CREATE_IF_NOT_EXISTS: bool> {
    /// Set the path to your sheet music file [default: stdin]
    input: Option<ClonableFile<CREATE_IF_NOT_EXISTS>>,
    /// Use this sheet music instead of reading from a file or stdin
    #[arg(short = 'c')]
    sheet_music_string: Option<String>,
}

#[derive(Debug)]
pub(super) struct ClonableFile<const CREATE_IF_NOT_EXISTS: bool>(File);

impl<const CREATE_IF_NOT_EXISTS: bool> Clone for ClonableFile<CREATE_IF_NOT_EXISTS> {
    fn clone(&self) -> Self {
        Self(self.0.try_clone().expect("cloning file handle"))
    }
}

impl<const CREATE_IF_NOT_EXISTS: bool> FromStr for ClonableFile<CREATE_IF_NOT_EXISTS> {
    type Err = io::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match CREATE_IF_NOT_EXISTS {
            true => File::create(s),
            false => File::open(s),
        }
        .map(Self)
    }
}

impl<const CREATE_IF_NOT_EXISTS: bool> From<ClonableFile<CREATE_IF_NOT_EXISTS>> for File {
    fn from(value: ClonableFile<CREATE_IF_NOT_EXISTS>) -> Self {
        value.0
    }
}

#[derive(Debug, Parser, Clone)]
pub(super) struct ExportOpts {
    #[command(flatten)]
    pub(super) playopts: PlayOpts,
    /// Audio format to use
    #[cfg_attr(
        feature = "mp3",
        arg(default_value = "mp3 --bitrate 128 --quality best")
    )]
    #[cfg_attr(
        not(feature = "mp3"),
        cfg_attr(feature = "raw", arg(default_value = "raw mulaw"))
    )]
    #[arg(short, long, value_parser = audio_format_parser)]
    pub(super) format: AudioFormat,
    /// Output file [default: stdout]
    #[arg(short, long)]
    pub(super) output: Option<ClonableFile<true>>,
}

#[derive(Clone, EnumDiscriminants)]
#[strum_discriminants(
    derive(EnumString, IntoStaticStr, EnumIter),
    strum(serialize_all = "lowercase")
)]
pub(super) enum AudioFormat {
    Mp3 {
        bitrate: Bitrate,
        quality: Quality,
    },
    Wav {
        bps: u16,
        sample_format: SampleFormat,
    },
    Flac {
        bps: usize,
    },
    Raw(RawAudioFormat),
}

impl Debug for AudioFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Raw(r) => f.debug_tuple("Raw").field(r).finish(),
            _ => self.discriminant().fmt(f),
        }
    }
}

impl Default for AudioFormat {
    fn default() -> Self {
        AudioFormat::Raw(Default::default())
    }
}

fn audio_format_parser(input: &str) -> Result<AudioFormat, anyhow::Error> {
    fn mp3<'a>() -> impl P<
        LocatedSpan<&'a str>,
        Output = AudioFormat,
        Error = nom::error::Error<LocatedSpan<&'a str>>,
    > {
        preceded(
            tag::<&'a str, LocatedSpan<&'a str>, nom::error::Error<LocatedSpan<&'a str>>>(
                AudioFormatDiscriminants::Mp3.into(),
            ),
            u16.or(success(320))
                .and(
                    alt((
                        value(Quality::Best, tag("b")),
                        value(Quality::SecondBest, tag("sb")),
                        value(Quality::NearBest, tag("nb")),
                        value(Quality::VeryNice, tag("v")),
                        value(Quality::Nice, tag("n")),
                        value(Quality::Good, tag("g")),
                        value(Quality::Decent, tag("d")),
                        value(Quality::Ok, tag("o")),
                        value(Quality::SecondWorst, tag("sw")),
                        value(Quality::Worst, tag("w")),
                    ))
                    .or(success(Quality::Good)),
                )
                .and(position)
                .map_res(|((b, q), p)| {
                    Ok(AudioFormat::Mp3 {
                        bitrate: match b {
                            8 => Bitrate::Kbps8,
                            16 => Bitrate::Kbps16,
                            24 => Bitrate::Kbps24,
                            32 => Bitrate::Kbps32,
                            40 => Bitrate::Kbps40,
                            48 => Bitrate::Kbps48,
                            64 => Bitrate::Kbps64,
                            80 => Bitrate::Kbps80,
                            96 => Bitrate::Kbps96,
                            112 => Bitrate::Kbps112,
                            128 => Bitrate::Kbps128,
                            160 => Bitrate::Kbps160,
                            192 => Bitrate::Kbps192,
                            224 => Bitrate::Kbps224,
                            256 => Bitrate::Kbps256,
                            320 => Bitrate::Kbps320,
                            _ => return Err(nom::error::Error::new(p, ErrorKind::Verify)),
                        },
                        quality: q,
                    })
                }),
        )
    }
    fn wav<'a>() -> impl P<
        LocatedSpan<&'a str>,
        Output = AudioFormat,
        Error = nom::error::Error<LocatedSpan<&'a str>>,
    > {
        preceded(
            tag::<&'a str, LocatedSpan<&'a str>, nom::error::Error<LocatedSpan<&'a str>>>(
                AudioFormatDiscriminants::Wav.into(),
            ),
            u16.or(success(32))
                .and(value(SampleFormat::Int, char('i')).or(success(SampleFormat::Float)))
                .map(|(bps, sample_format)| AudioFormat::Wav { bps, sample_format }),
        )
    }
    fn flac<'a>() -> impl P<
        LocatedSpan<&'a str>,
        Output = AudioFormat,
        Error = nom::error::Error<LocatedSpan<&'a str>>,
    > {
        preceded(
            tag::<&'a str, LocatedSpan<&'a str>, nom::error::Error<LocatedSpan<&'a str>>>(
                AudioFormatDiscriminants::Flac.into(),
            ),
            usize.or(success(16)).map(|bps| AudioFormat::Flac { bps }),
        )
    }
    fn parser<'a>() -> impl P<
        LocatedSpan<&'a str>,
        Output = AudioFormat,
        Error = nom::error::Error<LocatedSpan<&'a str>>,
    > {
        alt((
            mp3::<'a>(),
            wav::<'a>(),
            flac::<'a>(),
            rest.map_res(|r: LocatedSpan<&'a str>| {
                Ok::<AudioFormat, nom::error::Error<LocatedSpan<&'a str>>>(AudioFormat::Raw(
                    (*r == "raw")
                        .then_some(Default::default())
                        .ok_or(nom::error::Error::new(r, ErrorKind::Verify))
                        .or(RawAudioFormat::try_from(*r)
                            .map_err(|_| nom::error::Error::new(r, ErrorKind::Verify)))?,
                ))
            }),
        ))
    }
    parser()
        .parse_complete(LocatedSpan::new(input))
        .finish()
        .map(|(_, o)| o)
        .map_err(|e| anyhow!("{e:?}"))
}

#[derive(Debug, Parser, Clone, EnumString, Default, EnumIter, IntoStaticStr)]
#[strum(ascii_case_insensitive)]
pub(super) enum RawAudioFormat {
    ALaw,
    F32Be,
    F32Le,
    F64Be,
    F64Le,
    #[default]
    MuLaw,
    S8,
    S16Be,
    S16Le,
    S24Be,
    S24Le,
    S32Be,
    S32Le,
    U8,
    U16Be,
    U16Le,
    U24Be,
    U24Le,
    U32Be,
    U32Le,
}

#[derive(Debug, Parser, Clone)]
pub(super) enum MemoKind {
    #[command(flatten)]
    Syntax(SyntaxTarget),
    /// Show a list of examples or a specific example from the list
    Examples { n: Option<u8> },
    /// Print all available formats
    Formats,
}

#[derive(Debug, Parser, Clone)]
pub(super) enum SyntaxTarget {
    /// Print BLIP's grammar
    Blip,
    #[command(flatten)]
    Expressions(FastEvalSyntaxSection),
}

#[derive(Debug, Parser, Clone)]
pub(super) enum FastEvalSyntaxSection {
    /// Print available functions and constants for expressions
    Functions,
    /// Print available operators for expressions
    Ops,
    /// Print available literals for expressions
    Literals,
}