cliw 0.1.1

//! # Output for the web
//!
//! Writers for output to the web when compiling to wasm and running in a browser.
//! Depending on "console" and/or "alert" features, provides output to
//! [`console`] or a popup [`alert`].
//! Also basic [`print(&str)`] and [`eprint(&str)`] functions that use the web or standard output
//! depending on if compiled to native or wasm.
//!
//! This functionality is feature gated.  To enable getting output on wasm
//! you must enable at least one of "alert", "console", or "web-std-output" features.
//!
//! [`console`]: https://developer.mozilla.org/en-US/docs/Web/API/console
//! [`alert`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/alert
//! [`print(&str)`]: print()
//! [`eprint(&str)`]: eprint()

/// Write to console log and/or popup alert.
/// \
/// (For use on web/wasm)
///
/// Writes output to a popup [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
/// or the [`console log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static),
/// depending on if "alert" or "console" features are active.
/// \
/// Does nothing on native.
pub struct Stdout {}

/// Get a writer for output.
/// \
/// (For use on web/wasm)
///
/// Writes output to a popup [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
/// or the [`console log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static),
/// depending on if "alert" or "console" features are active.
/// \
/// Does nothing on native.
/// ## Example
/// ```rust
/// let mut writer = cliw::output::stdout();
/// ```
#[must_use]
pub const fn stdout() -> Stdout {
    Stdout {}
}

impl std::io::Write for Stdout {
    /// Write to console log and/or popup alert.
    /// \
    /// (For use on web/wasm)
    ///
    /// Writes output to a popup [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
    /// or the [`console log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static),
    /// depending on if "alert" or "console" features are active.
    /// \
    /// Does nothing on native.
    /// ## Example
    /// ```rust
    /// use std::io::Write;
    /// let mut writer = cliw::output::stdout();
    /// let _ = writer.write(b"Use web or stdout for output");
    /// ```
    fn write(&mut self, buffer: &[u8]) -> Result<usize, std::io::Error> {
        #[cfg(all(target_arch = "wasm32", feature = "alert"))]
        {
            let mut alert = Alert {};
            let _ = alert.write(buffer);
        }

        #[cfg(all(target_arch = "wasm32", feature = "console"))]
        {
            let mut console = console_log();
            let _ = console.write(buffer);
        }
        // Always Ok
        Ok(buffer.len())
    }

    /// Always Ok
    fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
        Ok(())
    }
}

/// Write to console error and/or popup alert.
/// \
/// (For use on web/wasm)
///
/// Writes errors to a popup [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
/// or the [`console error`](https://developer.mozilla.org/en-US/docs/Web/API/console/error_static),
/// depending on if "alert" or "console" features are active.
/// \
/// Does nothing on native.
pub struct Stderr {}

/// Get a writer for errors.
/// \
/// (For use on web/wasm)
///
/// Writes errors to a popup [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
/// or the [`console error`](https://developer.mozilla.org/en-US/docs/Web/API/console/error_static),
/// depending on if "alert" or "console" features are active.
/// \
/// Does nothing on native.
/// ## Example
/// ```rust
/// let mut writer = cliw::output::stderr();
/// ```
#[must_use]
pub const fn stderr() -> Stderr {
    Stderr {}
}

impl std::io::Write for Stderr {
    /// Write to console error and/or popup alert.
    /// \
    /// (For use on web/wasm)
    ///
    /// Writes errors to a popup [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
    /// or the [`console error`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_error),
    /// depending on if "alert" or "console" features are active.
    /// \
    /// Does nothing on native.
    /// ## Example
    /// ```rust
    /// use std::io::Write;
    /// let mut writer = cliw::output::stderr();
    /// let _ = writer.write(b"Use web or stderr for output");
    /// ```
    fn write(&mut self, buffer: &[u8]) -> Result<usize, std::io::Error> {
        #[cfg(all(target_arch = "wasm32", feature = "alert"))]
        {
            let mut alert = Alert {};
            let _ = alert.write(buffer);
        }

        #[cfg(all(target_arch = "wasm32", feature = "console"))]
        {
            let mut console = console_error();
            let _ = console.write(buffer);
        }
        // Always Ok
        Ok(buffer.len())
    }

    /// Always Ok
    fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
        Ok(())
    }
}

/// Popup an alert for output or errors.
/// \
/// (For use on web/wasm : with "alert" feature)
///
/// Writes output or errors to a popup
/// [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert) window.
/// \
/// Ignores errors from browser if a popup can not be created.
/// \
/// Does nothing on native.
pub struct Alert {}

/// Get a writer for output to popup alert.
/// \
/// (For use on web/wasm : with "alert" feature)
///
/// Writes output or errors to a popup
/// [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert) window.
/// \
/// Ignores errors from browser if a popup can not be created.
/// \
/// Does nothing on native.
/// ## Example
/// ```rust
/// let mut writer = cliw::output::alert();
/// ```
#[must_use]
pub const fn alert() -> Alert {
    Alert {}
}

impl std::io::Write for Alert {
    /// Popup an alert for output or errors.
    /// \
    /// (For use on web/wasm : with "alert" feature)
    ///
    /// Writes full buffer to pop-up
    /// [`alert`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert) window.
    /// \
    /// Ignores errors from browser if a popup can not be created.
    /// \
    /// Does nothing on native.
    /// ## Example
    /// ```rust
    /// use std::io::Write;
    /// let mut writer = cliw::output::alert();
    /// let _ = writer.write(b"Use popup alert for output");
    /// ```
    fn write(&mut self, buffer: &[u8]) -> Result<usize, std::io::Error> {
        #[cfg(all(target_arch = "wasm32", feature = "alert"))]
        {
            if let Some(window) = web_sys::window() {
                if let Ok(msg) = std::str::from_utf8(buffer) {
                    let _ = window.alert_with_message(msg);
                }
            }
        }
        // Always Ok
        Ok(buffer.len())
    }

    /// Always Ok
    /// \
    /// Does nothing on native.
    fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
        Ok(())
    }
}

/// Use js-sys console log for output.
/// \
/// (For use on web/wasm : with "console" feature)
///
/// Writes output to js-sys console
/// [`log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static).
/// \
/// Ignores errors from browser if a console can not be accessed.
/// \
/// Does nothing on native.
pub struct ConsoleLog {}

/// Get a writer for output to console log.
/// \
/// (For use on web/wasm : with "console" feature)
///
/// Writes output or errors to js-sys console
/// [`log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static).
/// \
/// Ignores errors from browser if a console can not be accessed.
/// \
/// Does nothing on native.
/// ## Example
/// ```rust
/// let mut writer = cliw::output::console_log();
/// ```
#[must_use]
pub const fn console_log() -> ConsoleLog {
    ConsoleLog {}
}

impl std::io::Write for ConsoleLog {
    /// Use js-sys console
    /// [`log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static)
    /// for output.
    /// \
    /// (For use on web/wasm : with "console" feature)
    ///
    /// Writes output or errors to js-sys console
    /// [`log`](https://developer.mozilla.org/en-US/docs/Web/API/console/log_static).
    /// \
    /// Ignores errors from browser if a console can not be accessed.
    /// \
    /// Does nothing on native.
    /// ## Example
    /// ```rust
    /// use std::io::Write;
    /// let mut writer = cliw::output::console_log();
    /// let _ = writer.write(b"Use console log for output");
    /// ```
    fn write(&mut self, buffer: &[u8]) -> Result<usize, std::io::Error> {
        #[cfg(all(target_arch = "wasm32", feature = "console"))]
        {
            if let Ok(msg) = std::str::from_utf8(buffer) {
                let msg = js_sys::JsString::from(msg);
                let ar = js_sys::Array::new();
                ar.push(&msg);
                web_sys::console::log(&ar);
            }
        }
        // Always Ok
        Ok(buffer.len())
    }

    /// Always Ok
    /// \
    /// Does nothing on native.
    fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
        Ok(())
    }
}

/// Use js-sys console error for output.
/// \
/// (For use on web/wasm : with "console" feature)
///
/// Writes errors to js-sys console
/// [`error`](https://developer.mozilla.org/en-US/docs/Web/API/console/error_static).
/// \
/// Ignores errors from browser if a console can not be accessed.
/// \
/// Does nothing on native.
pub struct ConsoleError {}

/// Get a writer for errors to console error.
/// \
/// (For use on web/wasm : with "console" feature)
///
/// Writes errors to js-sys console
/// [`error`](https://developer.mozilla.org/en-US/docs/Web/API/console/error_static).
/// \
/// Ignores errors from browser if a console can not be accessed.
/// \
/// Does nothing on native.
/// ## Example
/// ```rust
/// let mut writer = cliw::output::console_error();
/// ```
#[must_use]
pub const fn console_error() -> ConsoleError {
    ConsoleError {}
}

impl std::io::Write for ConsoleError {
    /// Use js-sys console
    /// [`error`](https://developer.mozilla.org/en-US/docs/Web/API/console/error_static)
    /// for output.
    /// \
    /// (For use on web/wasm : with "console" feature)
    ///
    /// Writes errors to js-sys console
    /// [`error`](https://developer.mozilla.org/en-US/docs/Web/API/console/error_static).
    /// \
    /// Ignores errors from browser if a console can not be accessed.
    /// \
    /// Does nothing on native.
    /// ## Example
    /// ```rust
    /// use std::io::Write;
    /// let mut writer = cliw::output::console_error();
    /// let _ = writer.write(b"Use console error for output");
    /// ```
    fn write(&mut self, buffer: &[u8]) -> Result<usize, std::io::Error> {
        #[cfg(all(target_arch = "wasm32", feature = "console"))]
        {
            if let Ok(msg) = std::str::from_utf8(buffer) {
                let msg = js_sys::JsString::from(msg);
                let ar = js_sys::Array::new();
                ar.push(&msg);
                web_sys::console::error(&ar);
            }
        }
        // Always Ok
        Ok(buffer.len())
    }

    /// Always Ok
    /// \
    /// Does nothing on native.
    fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
        Ok(())
    }
}

/// Print wrapper.
///
/// Use cliw output on web or standard out on native.
///
/// This function is feature gated.  To enable getting output on wasm
/// you must enable at least one of "alert", "console", or "web-std-output" features.
/// You always get standard output on native.
///
/// ## Example
/// ```rust
/// cliw::output::print("Use web or stdout for output");
/// let msg = format!("Format {} arguments", "some");
/// cliw::output::print(&msg);
/// ```
#[allow(unused_variables)]
pub fn print(msg: &str) {
    // _msg will not be used if there are no output features set.

    // If not on wasm, or if web-std-output is set use standard output
    #[cfg(any(not(target_arch = "wasm32"), feature = "web-std-output"))]
    {
        println!("{msg}");
    }

    // If on wasm, and either alert or console are set
    #[cfg(all(target_arch = "wasm32", any(feature = "alert", feature = "console")))]
    {
        use std::io::Write;
        let mut writer = stdout();
        let _ = writer.write(msg.as_bytes());
    }
}

/// Print errors wrapper.
///
/// Use cliw error output on web or standard error on native.
///
/// This function is feature gated.  To enable getting error output on wasm
/// you must enable at least one of "alert", "console", or "web-std-output" features.
/// You always get standard error output on native.
/// ## Example
/// ```rust
/// cliw::output::eprint("Use web or stdout for output");
/// let msg = format!("Format {} arguments", "some");
/// cliw::output::eprint(&msg);
/// ```
#[allow(unused_variables)]
pub fn eprint(msg: &str) {
    // msg will not be used if there are no output features set.

    // If not on wasm, or if web-std-output is set use standard output
    #[cfg(any(not(target_arch = "wasm32"), feature = "web-std-output"))]
    {
        eprintln!("{msg}");
    }

    // If on wasm, and either alert or console are set
    #[cfg(all(target_arch = "wasm32", any(feature = "alert", feature = "console")))]
    {
        use std::io::Write;
        let mut writer = stderr();
        let _ = writer.write(msg.as_bytes());
    }
}

#[cfg(test)]
mod tests {
    use crate::output::{eprint, print};

    #[test]
    fn test_output() {
        print("This is a test of output using cliw::output::print");
        eprint("This is a test of error output using cliw::output::eprint");
    }
}