proconio 0.6.0

// Copyright 2019 statiolake <statiolake@gmail.com>
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be copied, modified, or
// distributed except according to those terms.

#![allow(clippy::needless_doctest_main, clippy::print_literal)]

//! Easy IO library for competitive programming.
//!
//! `proconio` provides an easy way to read values from stdin (or other source).  The main feature
//! provided by this crate is `input!` macro (and its family, `read_value!`, `input_once!`,
//! and `read_value_once!`).
//!
//! # Examples
//!
//! The macro's user interface is basically the same with [tanakh's input
//! macro](https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8).
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let source = AutoSource::from("32 54 -23");
//!
//! input! {
//! #   from source,
//!     n: u8,
//!     m: u32,
//!     l: i32,
//! }
//!
//! // now you can use n, m and l as variable.
//! println!("{} {} {}", n, m, l);
//! # assert_eq!(n, 32);
//! # assert_eq!(m, 54);
//! # assert_eq!(l, -23);
//! ```
//!
//! In above code, variables n, m and l are declared and stored values are read from stdin.
//!
//! You can declare mutable variables like below:
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let source = AutoSource::from("32 54");
//!
//! input! {
//! #   from source,
//!     n: u32,
//!     mut m: u32,
//! }
//!
//! m += n; // OK: m is mutable
//! # assert_eq!(n, 32);
//! # assert_eq!(m, 86);
//! ```
//!
//! You can read an array or a matrix like this:
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let source = AutoSource::from("5 4 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5");
//!
//! input! {
//! #    from source,
//!     n: usize,
//!     m: usize,
//!     a: [[i32; n]; m] // `a` is Vec<Vec<i32>>, (m, n)-matrix.
//! }
//! # assert_eq!(
//! #     a,
//! #     [
//! #         [1, 2, 3, 4, 5],
//! #         [1, 2, 3, 4, 5],
//! #         [1, 2, 3, 4, 5],
//! #         [1, 2, 3, 4, 5]
//! #     ]
//! # );
//! ```
//!
//! If the first input is the length of the array, you can omit the length.  This is the only way
//! to read jagged array (an array of arrays of which the member arrays can be of different sizes)
//! at once.  (Of course you can use `input!` multiple times in for-loop to read such an array
//! since `input!` can be used multiple times.)
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let source = AutoSource::from("3 3 1 2 3 0 2 1 2");
//!
//! input! {
//! #   from source,
//!     n: usize,
//!     a: [[i32]; n],
//! }
//!
//! // if you enter "3  3 1 2 3  0  2 1 2" to the stdin, the result is as follows.
//! assert_eq!(
//!     a,
//!     vec![
//!         vec![1, 2, 3],
//!         vec![],
//!         vec![1, 2],
//!     ]
//! );
//! ```
//!
//! Strings can be read as `Vec<u8>` or `Vec<char>`.  Use `Bytes` and `Chars` to do so:
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! use proconio::marker::{Bytes, Chars};
//! # let source = AutoSource::from("  string   chars\nbytes");
//!
//! input! {
//! #     from source,
//!     string: String, // read as String
//!     chars: Chars,   // read as Vec<char>
//!     bytes: Bytes,   // read as Vec<u8>
//! }
//!
//! // if you enter "string chars bytes" to the stdin, they are like this.
//! assert_eq!(string, "string");
//! assert_eq!(chars, ['c', 'h', 'a', 'r', 's']);
//! assert_eq!(bytes, b"bytes");
//! ```
//!
//! You can read tuples:
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let source = AutoSource::from("1 2 3 4 5");
//!
//! input! {
//! #   from source,
//!     t: (i32, i32, i32, i32, i32),
//! }
//!
//! // if you enter "1 2 3 4 5" to the stdin, `t` is like this.
//! assert_eq!(t, (1, 2, 3, 4, 5));
//! ```
//!
//! And you can freely combine these types.
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let source = AutoSource::from("4 3 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5");
//!
//! input! {
//! #   from source,
//!     n: usize,
//!     m: usize,
//!     t: [([u32; m], i32); n],
//! }
//! # assert_eq!(
//! #     t,
//! #     [
//! #         (vec![1,1,1],1),
//! #         (vec![2,2,2],2),
//! #         (vec![3,3,3],3),
//! #         (vec![4,4,4],4),
//! #     ]
//! # );
//! ```
//!
//! You can use `input!` macro multiple times.  For the second time, `input!` macro reads rest of
//! input.  It works even if the first input stops at the middle of a line.  The subsequent reads
//! will be started at the rest of the line.  This may be helpful for problems where multiple
//! datasets are given once.
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! # let mut source = AutoSource::from("4 2 1 2 2 3 4 2 1 2 2 3 4");
//!
//! input! {
//! #   from &mut source,
//!     n: usize,
//! }
//!
//! for i in 0..n {
//!     input! {
//! #       from &mut source,
//!         m: usize,
//!         a: [i32; m],
//!     }
//! #   assert_eq!(a[0], if i % 2 == 0 { 1 } else { 3 });
//! #   assert_eq!(a[1], if i % 2 == 0 { 2 } else { 4 });
//! }
//! ```
//!
//! In addition to `Chars` and `Bytes`, `Usize1` and `Isize1` are also special types.  They are
//! read as `usize` and `isize` respectively, but the read value is decremented.  It enables us to
//! automatically convert 1-indexed vertices numbers to 0-indexed array indices.
//!
//! ```
//! # extern crate proconio;
//! # use proconio::source::auto::AutoSource;
//! use proconio::input;
//! use proconio::marker::Usize1;
//! # let mut source = AutoSource::from("4   1 3   3 4   6 1   5 3");
//!
//! input! {
//! #   from &mut source,
//!     n: usize,
//!     edges: [(Usize1, Usize1); n],
//! }
//!
//! // if you enter "4   1 3   3 4   6 1   5 3", the decremented value is stored.
//! assert_eq!(edges[0], (0, 2));
//! assert_eq!(edges[1], (2, 3));
//! assert_eq!(edges[2], (5, 0));
//! assert_eq!(edges[3], (4, 2));
//! ```
//!
//! `Usize1` and `Isize1` doesn't hold actual value, so you cannot have value of the type.  Thus,
//! they are only useful inside `input!` or `#[derive_readable]`.  You can think the reason these
//! types exist is to tell "how to read the value".  This how-to can be defined through `Readable`
//! trait.  This trait doesn't require the output type to be the same with the implementor.
//! `Usize1` is implementing `Readable` trait, and there the type of read value is defined as
//! `usize`.  You can implement `Readable` for your own type to read values in customized way.
//!
//! Finally, you can make your own types `Readable` using `#[derive_readable]` attribute.  Types
//! used in the struct are automatically translated to their output types, so a member declared as
//! `Usize1` has type `usize` as real struct.
//!
//! **Note:** Using `#[derive_readable]` requires `derive` feature enabled.  To do so, open your
//! Cargo.toml and modify the line of proconio from:
//!
//! ```toml
//! proconio = "=(version)"
//! ```
//!
//! to:
//!
//! ```toml
//! proconio = { version = "=(version)", features = ["derive"] }
//! ```
//!
//! Example of `#[derive_readable]`:
//!
//! ```
//! # #[cfg(feature = "derive")]
//! # {
//! # extern crate proconio;
//! use proconio::input;
//! # use proconio::source::auto::AutoSource;
//! use proconio::derive_readable;
//!
//! // Unit struct can derive readable.  This generates a no-op for the reading.  Not ignoring
//! // the read value, but simply skip reading process.  You cannot use it to discard the input.
//! #[derive_readable]
//! #[derive(PartialEq, Debug)]
//! struct Weight;
//!
//! #[derive_readable]
//! #[derive(PartialEq, Debug)]
//! struct Cost(i32);
//!
//! #[derive_readable]
//! #[derive(Debug)]
//! struct Edge {
//!     from: usize,
//!     to: proconio::marker::Usize1, // The real Edge::to has type usize.
//!     weight: Weight,
//!     cost: Cost,
//! }
//!
//! fn main() {
//! #   let source = AutoSource::from("12 32 35");
//!     input! {
//! #       from source,
//!         edge: Edge,
//!     }
//!
//!     // if you enter "12 32 35" to the stdin, the values are as follows.
//!     assert_eq!(edge.from, 12);
//!     assert_eq!(edge.to, 31);
//!     assert_eq!(edge.weight, Weight);
//!     assert_eq!(edge.cost, Cost(35));
//! }
//! # }
//! ```
//!
//! # `read_value!` macro
//!
//! `read_value!` macro is a macro used inside the `input!` macro, but using it directly is also
//! useful in some cases. Typically when you don't need to store the value into a variable.
//!
//! ```rust
//! # extern crate proconio;
//! use proconio::source::auto::AutoSource;
//! use proconio::read_value;
//! let mut source = AutoSource::from("2 3 4");
//! let mut sum = 0;
//! for _ in 0..read_value!(from &mut source, usize) {
//!     sum += read_value!(from &mut source, u32);
//! }
//! assert_eq!(sum, 7);
//! ```
//!
//! # Line-by-line input by default
//!
//! As of 0.6.0, `input!` and `read_value!` always read stdin line by line.  This is a
//! deliberate change.  Previously, debug builds read line by line but release builds read
//! everything at once.  That mismatch between local testing and the judge occasionally
//! caused trouble, most notably with interactive problems.  Meanwhile, input speed is
//! rarely the bottleneck in Rust, so this change should not cause TLEs in practice.
//!
//! The old line-by-line macros, `input_interactive!` and `read_value_interactive!`, are
//! still available but now deprecated, since `input!` and `read_value!` do the same job.
//!
//! If you still want the fastest possible I/O for non-interactive problems, use
//! `input_once!` and `read_value_once!` instead.  They read the entire input at once,
//! which is slightly faster than reading line by line.  They do not work with interactive
//! problems, and cannot be mixed with the line-by-line macros in one program.
//!
//! The usage of those macros is the same as the normal ones.  Refer to the documentation of
//! [input!](input) and [read_value!](read_value) for further information.
//!
//! # `#[fastout]`
//!
//! If you import `proconio::fastout`, you can use `#[fastout]` attribute.  Adding this attribute
//! to your `main()`, your `print!` and `println!` become faster.
//!
//! **Note:** Using `#[proconio::fastout]` requires `derive` feature enabled.  To do so, open your
//! Cargo.toml and modify the line of proconio from:
//!
//! ```toml
//! proconio = "=(version)"
//! ```
//!
//! to:
//!
//! ```toml
//! proconio = { version = "=(version)", features = ["derive"] }
//! ```
//!
//! Example of `#[fastout]`:
//!
//! ```
//! # #[cfg(feature = "derive")]
//! # {
//! # extern crate proconio;
//! use proconio::fastout;
//!
//! #[fastout]
//! fn main() {
//!     print!("{}{}, ", 'h', "ello"); // "hello"       (no newline)
//!     println!("{}!", "world");      // "world!\n"
//!     println!("{}", 123456789);     // "123456789\n"
//! }
//! # }
//! ```
//!
//! ## Closures having `print!` or `println!` in `#[fastout]` function
//!
//! You cannot create a closure containing `print!` or `println!` in `#[fastout]` function.  This
//! is because the closure becomes thread-unsafe since the closure refers the unlocked stdout
//! introduced by `#[fastout]` attribute.  If this were not prohibited, an invalid usage of such a
//! closure would produce a very complex error messages.  For example, `std::thread::spawn()`,
//! which requires its argument closure to be thread-safe, causes a confusing error.
//!
//! Yes, it is too conservative to make all of such closures compilation error because it is
//! actually no problem to use such a closure only inside a single thread.  This is related to a
//! limitation in `#[fastout]` implementation.
//!
//! For more technical details, see documentation for `#[fastout]` in `proconio-derive`.
//!
//! ### How to resolve this error
//!
//! Consider you want to run this code:
//!
//! ```compile_fail
//! use proconio::fastout;
//!
//! #[fastout]
//! fn main() {
//!     let thread = std::thread::spawn(|| {
//!         let x = 3;
//!         let y = x * x;
//!         println!("{}", y);
//!     });
//!
//!     thread.join().unwrap();
//! }
//! ```
//!
//! You will get an error like below.
//!
//! ```text
//! error: Closures in a #[fastout] function cannot contain `print!` or `println!` macro
//!
//! note: If you want to run your entire logic in a thread having extended size of stack, you can
//! define a new function instead.  See documentation (https://.....) for more details.
//!
//! note: This is because if you use this closure with `std::thread::spawn()` or any other
//! functions requiring `Send` for an argument closure, the compiler emits an error about thread
//! unsafety for our internal implementations.  If you are using the closure just in a single
//! thread, it's actually no problem, but we cannot check the trait bounds at the macro-expansion
//! time.  So for now, all closures having `print!` or `println!` is prohibited regardless of the
//! `Send` requirements.
//!  --> src/test.rs:10:9
//!    |
//! 10 |         println!("{}", y);
//!    |         ^^^^^^^
//! ```
//!
//! If your `print!` is relying on the calculation in the thread, you can instead return the result
//! from the thread.
//!
//! ```
//! # #[cfg(feature = "derive")]
//! # {
//! use proconio::fastout;
//!
//! #[fastout]
//! fn main() {
//!     let thread = std::thread::spawn(|| {
//!         let x = 3;
//!         x * x
//!     });
//!
//!     let y = thread.join().unwrap();
//! #   assert_eq!(y, 9);
//!     println!("{}", y);
//! }
//! # }
//! ```
//!
//! If you are doing so complex job that it's too difficult to returning the results from your
//! closure...
//!
//! ```compile_fail
//! use proconio::fastout;
//!
//! # fn some_function(_: String) -> impl Iterator<Item = String> { vec!["hello".to_string(), "world".to_string()].into_iter() }
//! # fn some_proc(x: &str) -> &str { x }
//!
//! #[fastout]
//! fn main() {
//!     let context = "some context".to_string();
//!     let thread = std::thread::spawn(move || {
//!         // Use many println! and the order is very important
//!         // It's possible to aggregate the result and print it later, but it's not easy to read
//!         // and seems ugly.
//!         println!("this is header.");
//!         for (i, item) in some_function(context).enumerate() {
//!             print!("Item #{}: ", i);
//!             print!("{}", some_proc(&item));
//!             println!("({})", item);
//!         }
//!     });
//!
//!     thread.join().unwrap();
//! }
//! ```
//!
//! ...you can use a function instead.
//!
//! ```
//! # #[cfg(feature = "derive")]
//! # {
//! use proconio::fastout;
//!
//! # fn some_function(_: String) -> impl Iterator<Item = String> { vec!["hello".to_string(), "world".to_string()].into_iter() }
//! # fn some_proc(x: &str) -> &str { x }
//!
//! // You can add #[fastout] here
//! #[fastout]
//! fn process(context: String) {
//!     // It's completely OK since this #[fastout] is a thing inside `process()`
//!     println!("this is header.");
//!     for (i, item) in some_function(context).enumerate() {
//!         print!("Item #{}: ", i);
//!         print!("{}", some_proc(&item));
//!         println!("({})", item);
//!     }
//! }
//!
//! // You must not add #[fastout] here!  It causes deadlock.
//! // #[fastout]
//! fn main() {
//!     let context = "some context".to_string();
//!     let thread = std::thread::spawn(move || process(context));
//!     thread.join().unwrap();
//! }
//! # }
//! ```
//!
//! **Important Note:** If you *spawn a new thread* which runs another function annotated with
//! `#[fastout]`, you must not add `#[fastout]` to the caller.  If you add `#[fastout]` in caller
//! too, then the caller has the lock for the stdout, and so callee cannot acquire the lock forever
//! --- deadlock.  This is not the case when the caller and callee is executed in the same thread,
//! since the lock of stdout is reentrant.  We cannot warn about this kind of deadlock since we
//! don't know annotations attached to the function to be called.  (In the above example, we can't
//! know whether the function `process()` has `#[fastout]` attribute or not.)
//!
//! If your code is so complex that you cannot avoid deadlock, you should give up using
//! `#[fastout]` and simply use `println!` or manually handle your stdout in usual Rust way.
//!
//! ## Issues of printing order
//!
//! `#[fastout]` enables buffering to stdout, so if you print something in other functions between
//! two prints in main, the order of printing may differ.  In other words, the below example
//!
//! ```
//! # #[cfg(feature = "derive")]
//! # {
//! # use proconio::fastout;
//! fn foo() { println!("between"); }
//! #[fastout]
//! fn main() {
//!     println!("hello");
//!     foo();
//!     println!("world");
//! }
//! # }
//! ```
//!
//! *likely* prints like
//!
//! ```text
//! between
//! hello
//! world
//! ```
//!
//! If you don't like this behavior, you can remove `#[fastout]` from your `main()`.
//!

#[cfg(feature = "derive")]
pub use proconio_derive::*;

pub mod marker;
pub mod source;

use crate::source::{line::LineSource, once::OnceSource};
use std::sync::OnceLock;
use std::{
    io::{self, BufRead},
    sync::Mutex,
};
use std::{
    io::{BufReader, Stdin},
    sync::MutexGuard,
};

// Prepares a short path to `Readable` to enables rust-analyzer to infer `Readable::Output`.
#[doc(hidden)]
pub use crate::source::Readable as __Readable;

pub enum StdinSource<R: BufRead> {
    Line(LineSource<R>), // for input!, read_value! and is_stdin_empty()
    Once(OnceSource<R>), // for input_once! and read_value_once!
}

impl<R: BufRead> source::Source<R> for StdinSource<R> {
    fn next_token(&mut self) -> Option<&str> {
        match self {
            StdinSource::Line(source) => source.next_token(),
            StdinSource::Once(source) => source.next_token(),
        }
    }

    fn is_empty(&mut self) -> bool {
        match self {
            StdinSource::Line(source) => source.is_empty(),
            StdinSource::Once(source) => source.is_empty(),
        }
    }
}

#[doc(hidden)]
pub static STDIN_SOURCE: OnceLock<Mutex<StdinSource<BufReader<Stdin>>>> = OnceLock::new();

/// Read input and define variable from specified source.
///
/// Basic syntax is:
///
/// ```text
/// input! {
///     from source,          // optional: if you omitted, stdin is used by default.
///     (mut) variable: type, // mut is optional: mut makes the variable mutable.
///     (mut) variable: with runtime_readable, // RuntimeReadable version.
///     ...
/// }
/// ```
///
/// The trailing comma is optional.  `source` can be anything implementing `Source`.  This macro
/// moves out the specified source.  If you want to prevent moving, you can use `&mut source` since
/// `&mut S` where `S: Source` also implements `Source`.
#[macro_export]
macro_rules! input {
    // terminator
    (@from [$source:expr] @rest) => {};

    // parse mutability
    (@from [$source:expr] @rest mut $($rest:tt)*) => {
        $crate::input! {
            @from [$source]
            @mut [mut]
            @rest $($rest)*
        }
    };
    (@from [$source:expr] @rest $($rest:tt)*) => {
        $crate::input! {
            @from [$source]
            @mut []
            @rest $($rest)*
        }
    };

    // parse variable pattern
    (@from [$source:expr] @mut [$($mut:tt)?] @rest $var:tt: $($rest:tt)*) => {
        $crate::input! {
            @from [$source]
            @mut [$($mut)*]
            @var $var
            @kind []
            @rest $($rest)*
        }
    };

    // parse `with` (the marker of RuntimeReadable type)
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [] @rest with $($rest:tt)*) => {
        $crate::input! {
            @from [$source]
            @mut [$($mut)*]
            @var $var
            @dyn_kind []
            @rest $($rest)*
        }
    };

    // parse kind (Readable type)
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [$($kind:tt)*] @rest) => {
        let $($mut)* $var = $crate::read_value!(@source [$source] @kind [$($kind)*]);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [$($kind:tt)*] @rest, $($rest:tt)*) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @kind [$($kind)*] @rest);
        $crate::input!(@from [$source] @rest $($rest)*);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [] @rest [$($tt:tt)*] $($rest:tt)*) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @kind [[$($tt)*]] @rest $($rest)*);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [] @rest ($($tt:tt)*) $($rest:tt)*) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @kind [($($tt)*)] @rest $($rest)*);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [] @rest $ty:ty, $($rest:tt)*) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @kind [$ty] @rest, $($rest)*);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @kind [] @rest $ty:ty) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @kind [$ty] @rest);
    };

    // parse runtime kind (RuntimeReadable type)
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @dyn_kind [$($dyn_kind:tt)*] @rest) => {
        let $($mut)* $var = $crate::read_value!(@source [$source] @dyn_kind [$($dyn_kind)*]);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @dyn_kind [$($dyn_kind:tt)*] @rest, $($rest:tt)*) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @dyn_kind [$($dyn_kind)*] @rest);
        $crate::input!(@from [$source] @rest $($rest)*);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @dyn_kind [$($dyn_kind:tt)*] @rest $dyn_readable:expr) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @dyn_kind [$($dyn_kind)* $dyn_readable] @rest);
    };
    (@from [$source:expr] @mut [$($mut:tt)?] @var $var:tt @dyn_kind [$($dyn_kind:tt)*] @rest $dyn_readable:expr, $($rest:tt)*) => {
        $crate::input!(@from [$source] @mut [$($mut)*] @var $var @dyn_kind [$($dyn_kind)* $dyn_readable] @rest , $($rest)*);
    };
    (@from $($tt:tt)*) => {
        compile_error!(concat!(
            "Reached unreachable statement while parsing macro input.  ",
            "This is a bug in `proconio`.  ",
            "Please report this issue from ",
            "<https://github.com/statiolake/proconio-rs/issues>."
        ));
    };

    // interface
    (from $source:expr, $($rest:tt)*) => {
        #[allow(unused_variables, unused_mut)]
        let mut s = $source;
        $crate::input! {
            @from [&mut s]
            @rest $($rest)*
        }
    };
    ($($rest:tt)*) => {
        let mut locked_stdin = $crate::__acquire_global_stdin_lock_line();
        $crate::input! {
            @from [&mut *locked_stdin]
            @rest $($rest)*
        }
        drop(locked_stdin); // release the lock
    };
}

/// Deprecated alias of input! macro.
///
/// The input! macro now always reads the input line by line and works for interactive problems
/// out of the box, so this macro is no longer needed. It is kept as an alias of input! for
/// backward compatibility. Read the document of [input!](input) for further information.
#[deprecated(
    since = "0.6.0",
    note = "`input!` now always reads the input line by line and works for interactive problems; use `input!` instead"
)]
#[macro_export]
macro_rules! input_interactive {
    ($($rest:tt)*) => {
        $crate::input! {
            $($rest)*
        }
    };
}

/// Faster version of input! macro, reading the entire input at once.
///
/// This macro reads the entire input at the first invocation and gives out tokens from the
/// buffered input afterwards, which is slightly faster than the line-by-line reading of input!
/// macro. Note the following restrictions:
///
/// - It does not work with interactive problems: the first invocation blocks until the input
///   reaches EOF. For the same reason, when you feed the input by hand in a terminal, you need to
///   terminate the input by EOF (Ctrl-D on Unix or Ctrl-Z on Windows).
/// - It cannot be mixed with the line-by-line macros (input!, read_value! or is_stdin_empty())
///   in one program. Such a mixed use causes a panic at run time.
/// - It does not support the `from source` syntax. Use input! if you want to read from your own
///   source.
///
/// Other than that, usage are the same with input! macro. Read the document of [input!](input)
/// for further information.
#[macro_export]
macro_rules! input_once {
    (from $($rest:tt)*) => {
        compile_error!(concat!(
            "`input_once!` does not support the `from source` syntax.  ",
            "Use `input!` with your own source instead."
        ));
    };
    ($($rest:tt)*) => {
        let mut locked_stdin = $crate::__acquire_global_stdin_lock_once();
        $crate::input! {
            @from [&mut *locked_stdin]
            @rest $($rest)*
        }
        drop(locked_stdin); // release the lock
    };
}

/// Read input from specified source.
/// Basic syntax is:
///
/// ```text
/// let variable = read_value!(type);
/// let variable = read_value!(with runtime_readable);
/// // or
/// let variable = read_value!(from source, type);
/// let variable = read_value!(from source, with runtime_readable);
/// ```
///
/// You can use any types that can be used with input! macro.
#[macro_export]
macro_rules! read_value {
    // array and variable length array
    (@source [$source:expr] @kind [[$($kind:tt)*]]) => {
        $crate::read_value!(@array @source [$source] @kind [] @rest $($kind)*)
    };
    (@array @source [$source:expr] @kind [$($kind:tt)*] @rest) => {{
        let len = <usize as $crate::__Readable>::read($source);
        $crate::read_value!(@source [$source] @kind [[$($kind)*; len]])
    }};
    (@array @source [$source:expr] @kind [$($kind:tt)*] @rest ; $($rest:tt)*) => {
        $crate::read_value!(@array @source [$source] @kind [$($kind)*] @len [$($rest)*])
    };
    (@array @source [$source:expr] @kind [$($kind:tt)*] @rest $tt:tt $($rest:tt)*) => {
        $crate::read_value!(@array @source [$source] @kind [$($kind)* $tt] @rest $($rest)*)
    };
    (@array @source [$source:expr] @kind [$($kind:tt)*] @len [$($len:tt)*]) => {{
        let len = $($len)*;
        (0..len)
            .map(|_| $crate::read_value!(@source [$source] @kind [$($kind)*]))
            .collect::<Vec<_>>()
    }};

    // tuple
    (@source [$source:expr] @kind [($($kinds:tt)*)]) => {
        $crate::read_value!(@tuple @source [$source] @kinds [] @current [] @rest $($kinds)*)
    };
    (@tuple @source [$source:expr] @kinds [$([$($kind:tt)*])*] @current [] @rest) => {
        (
            $($crate::read_value!(@source [$source] @kind [$($kind)*]),)*
        )
    };
    (@tuple @source [$source:expr] @kinds [$($kinds:tt)*] @current [$($curr:tt)*] @rest) => {
        $crate::read_value!(@tuple @source [$source] @kinds [$($kinds)* [$($curr)*]] @current [] @rest)
    };
    (@tuple @source [$source:expr] @kinds [$($kinds:tt)*] @current [$($curr:tt)*] @rest, $($rest:tt)*) => {
        $crate::read_value!(@tuple @source [$source] @kinds [$($kinds)* [$($curr)*]] @current [] @rest $($rest)*)
    };
    (@tuple @source [$source:expr] @kinds [$($kinds:tt)*] @current [$($curr:tt)*] @rest $tt:tt $($rest:tt)*) => {
        $crate::read_value!(@tuple @source [$source] @kinds [$($kinds)*] @current [$($curr)* $tt] @rest $($rest)*)
    };

    // normal other
    (@source [$source:expr] @kind [$kind:ty]) => {
        <$kind as $crate::__Readable>::read($source)
    };

    // runtime readable
    (@source [$source:expr] @dyn_kind [$dyn_kind:expr]) => {
        $crate::source::RuntimeReadable::read($dyn_kind, $source)
    };

    // unreachable
    (@source [$source:expr] @kind []) => {
        compile_error!(concat!(
            "Reached unreachable statement while parsing macro input.  ",
            "This is a bug in `proconio`.  ",
            "Please report this issue from ",
            "<https://github.com/statiolake/proconio-rs/issues>."
        ));
    };

    // interface
    (from $source:expr, with $($rest:tt)*) => {{
        #[allow(unused_variables, unused_mut)]
        let mut s = $source;
        $crate::read_value!(@source [&mut s] @dyn_kind [$($rest)*])
    }};
    (from $source:expr, $($rest:tt)*) => {{
        #[allow(unused_variables, unused_mut)]
        let mut s = $source;
        $crate::read_value!(@source [&mut s] @kind [$($rest)*])
    }};
    ($($rest:tt)*) => {{
        let mut locked_stdin = $crate::__acquire_global_stdin_lock_line();
        let __res = $crate::read_value!(from &mut *locked_stdin, $($rest)*);
        drop(locked_stdin); // release the lock
        __res
    }};
}

/// Deprecated alias of `read_value!` macro.
///
/// The read_value! macro now always reads the input line by line and works for interactive
/// problems out of the box, so this macro is no longer needed. It is kept as an alias of
/// read_value! for backward compatibility. Read the document of [read_value!](read_value) for
/// further information.
#[deprecated(
    since = "0.6.0",
    note = "`read_value!` now always reads the input line by line and works for interactive problems; use `read_value!` instead"
)]
#[macro_export]
macro_rules! read_value_interactive {
    ($($rest:tt)*) => {
        $crate::read_value!($($rest)*)
    };
}

/// Faster version of `read_value!` macro, reading the entire input at once.
///
/// The restrictions of [input_once!](input_once) apply to this macro as well: it does not work
/// with interactive problems, cannot be mixed with the line-by-line macros in one program, and
/// does not support the `from source` syntax. Other than that, usage are the same with
/// read_value! macro. Read the document of [read_value!](read_value) for further information.
#[macro_export]
macro_rules! read_value_once {
    (from $($rest:tt)*) => {
        compile_error!(concat!(
            "`read_value_once!` does not support the `from source` syntax.  ",
            "Use `read_value!` with your own source instead."
        ));
    };
    ($($rest:tt)*) => {{
        let mut locked_stdin = $crate::__acquire_global_stdin_lock_once();
        let __res = $crate::read_value!(from &mut *locked_stdin, $($rest)*);
        drop(locked_stdin); // release the lock
        __res
    }};
}

// Acquires the global stdin lock, initializing the source as the line-by-line reader if it is not
// initialized yet. This must be public because it appears in macro-expanded code, but hidden in
// doc because this implementation detail should be considered as private.
#[doc(hidden)]
pub fn __acquire_global_stdin_lock_line() -> MutexGuard<'static, StdinSource<BufReader<Stdin>>> {
    let locked_stdin = lock_global_stdin_source(|| {
        StdinSource::Line(LineSource::new(BufReader::new(io::stdin())))
    });
    if let StdinSource::Once(_) = &*locked_stdin {
        panic!(concat!(
            "cannot use `input!` / `read_value!` (or their deprecated `_interactive` aliases) ",
            "or `is_stdin_empty()` after `input_once!` / `read_value_once!`: the stdin source ",
            "is already initialized to read the entire input at once.  ",
            "Please use only one family of the macros in a program."
        ));
    }
    locked_stdin
}

// Acquires the global stdin lock, initializing the source as the read-at-once reader if it is not
// initialized yet. This must be public because it appears in macro-expanded code, but hidden in
// doc because this implementation detail should be considered as private.
#[doc(hidden)]
pub fn __acquire_global_stdin_lock_once() -> MutexGuard<'static, StdinSource<BufReader<Stdin>>> {
    let locked_stdin = lock_global_stdin_source(|| {
        StdinSource::Once(OnceSource::new(BufReader::new(io::stdin())))
    });
    if let StdinSource::Line(_) = &*locked_stdin {
        panic!(concat!(
            "cannot use `input_once!` / `read_value_once!` after `input!` / `read_value!` ",
            "(or their deprecated `_interactive` aliases) or `is_stdin_empty()`: the stdin ",
            "source is already initialized to read the input line by line.  ",
            "Please use only one family of the macros in a program."
        ));
    }
    locked_stdin
}

fn lock_global_stdin_source(
    init: impl FnOnce() -> StdinSource<BufReader<Stdin>>,
) -> MutexGuard<'static, StdinSource<BufReader<Stdin>>> {
    STDIN_SOURCE
        .get_or_init(|| Mutex::new(init()))
        .lock()
        .expect(concat!(
            "failed to lock the stdin; please re-run this program.  ",
            "If this issue repeatedly occur, this is a bug in `proconio`.  ",
            "Please report this issue from ",
            "<https://github.com/statiolake/proconio-rs/issues>."
        ))
}

/// Checks if some of tokens are left on stdin.
///
/// This is useful when the number of test cases is not specified like ICPC problems.
///
/// ```text
/// loop {
///     if is_stdin_empty() {
///         break;
///     }
///
///     // do the normal logic
///     input! { ... }
/// }
/// ```
pub fn is_stdin_empty() -> bool {
    use source::Source;
    // Note: this works with whichever source is in use, but if this is the first access to
    // stdin, it initializes the source as the line-by-line reader. In other words, calling this
    // function first and then using `input_once!` / `read_value_once!` is not allowed.
    let mut lock = lock_global_stdin_source(|| {
        StdinSource::Line(LineSource::new(BufReader::new(io::stdin())))
    });
    lock.is_empty()
}

#[cfg(test)]
mod tests {
    use std::marker::PhantomData;

    use crate::source::auto::AutoSource;

    #[test]
    fn input_empty() {
        let source = AutoSource::from("");
        input! {
            from source,
        }
    }

    #[test]
    fn input_number() {
        let source = AutoSource::from("    32   54 -23\r\r\n\nfalse");

        input! {
            from source,
            n: u8,
            m: u32,
            l: i32,
        }

        assert_eq!(n, 32);
        assert_eq!(m, 54);
        assert_eq!(l, -23);
    }

    #[test]
    fn read_value_number() {
        let mut source = AutoSource::from("    32   54 -23\r\r\n\nfalse");

        assert_eq!(read_value!(from &mut source, u8), 32);
        assert_eq!(read_value!(from &mut source, u32), 54);
        assert_eq!(read_value!(from &mut source, i32), -23);
    }

    #[test]
    fn input_str() {
        use crate::marker::{Bytes, Chars};
        let source = AutoSource::from("  string   chars\nbytes");

        input! {
            from source,
            string: String,
            chars: Chars,
            bytes: Bytes,
        }

        assert_eq!(string, "string");
        assert_eq!(chars, ['c', 'h', 'a', 'r', 's']);
        assert_eq!(bytes, b"bytes");
    }

    #[test]
    fn read_value_str() {
        use crate::marker::{Bytes, Chars};
        let mut source = AutoSource::from("  string   chars\nbytes");

        assert_eq!(read_value!(from &mut source, String), "string");
        assert_eq!(
            read_value!(from &mut source, Chars),
            ['c', 'h', 'a', 'r', 's']
        );
        assert_eq!(read_value!(from &mut source, Bytes), b"bytes");
    }

    #[test]
    fn input_array() {
        let source = AutoSource::from("5 3 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5");

        input! {
            from source,
            n: usize,
            m: usize,
            a: [i32; n],
            b: [[i32; n]; m] // no trailing comma is OK
        }

        assert_eq!(a, [1, 2, 3, 4, 5]);
        assert_eq!(b, [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]);
    }

    #[test]
    fn read_value_array() {
        let mut source = AutoSource::from("5 3 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5");

        let n = read_value!(from &mut source, usize);
        let m = read_value!(from &mut source, usize);
        let a = read_value!(from &mut source, [i32; n]);
        let b = read_value!(from &mut source, [[i32; n]; m]);

        assert_eq!(a, [1, 2, 3, 4, 5]);
        assert_eq!(b, [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]);
    }

    #[test]
    fn input_vla() {
        let source = AutoSource::from("5 3 1 2 3 2 1 2 4 1 2 3 4 0 6 1 2 3 4 5 6");

        input! {
            from source,
            n: usize,
            a: [[i32]; n],
        }

        assert_eq!(
            a,
            vec![
                vec![1, 2, 3],
                vec![1, 2],
                vec![1, 2, 3, 4],
                vec![],
                vec![1, 2, 3, 4, 5, 6],
            ]
        );
    }

    #[test]
    fn read_value_vla() {
        let mut source = AutoSource::from("5 3 1 2 3 2 1 2 4 1 2 3 4 0 6 1 2 3 4 5 6");

        let n = read_value!(from &mut source, usize);
        let a = read_value!(from &mut source, [[i32]; n]);

        assert_eq!(
            a,
            vec![
                vec![1, 2, 3],
                vec![1, 2],
                vec![1, 2, 3, 4],
                vec![],
                vec![1, 2, 3, 4, 5, 6],
            ]
        );
    }

    #[test]
    fn input_tuple() {
        let mut source = AutoSource::from("4 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5");

        let n = read_value!(from &mut source, usize);
        let t = read_value!(from &mut source, [(i32, i32, i32, i32, i32); n]);

        assert_eq!(
            t,
            [
                (1, 2, 3, 4, 5),
                (1, 2, 3, 4, 5),
                (1, 2, 3, 4, 5),
                (1, 2, 3, 4, 5)
            ]
        );
    }

    #[test]
    fn input_multiple_times() {
        let mut source = AutoSource::from("4 1 2 3 4\n1 2\r\n\r\r\n3 4");

        input! {
            from &mut source,
            n: usize,
        }

        for i in 0..n {
            input! {
                from &mut source,
                j: i32, k: i32,
            }

            assert_eq!(j, if i % 2 == 0 { 1 } else { 3 });
            assert_eq!(k, if i % 2 == 0 { 2 } else { 4 });
        }
    }

    #[test]
    fn input_iusize1() {
        use crate::marker::Usize1;

        let mut source = AutoSource::from("4 1 2 3 4 5 6 7 8");

        input! {
            from &mut source,
            n: usize,
        }

        for i in 0..n {
            input! {
                from &mut source,
                from: Usize1, to: Usize1
            }

            assert_eq!(from, i * 2);
            assert_eq!(to, i * 2 + 1);
        }
    }

    #[test]
    #[should_panic]
    fn input_zero_as_usize1() {
        use crate::marker::Usize1;
        let mut source = AutoSource::from("0");
        input! {
            from &mut source,
            _v: Usize1,
        }
    }

    #[test]
    #[should_panic]
    fn input_min_as_isize1() {
        use crate::marker::Isize1;
        let min_string = isize::MIN.to_string();
        let mut source = AutoSource::from(&*min_string);
        input! {
            from &mut source,
            _v: Isize1,
        }
    }

    #[test]
    fn input_mut() {
        let mut source = AutoSource::from("8 1 2 3 4 5 6 7 8");

        input! {
            from &mut source,
            mut n: usize,
        }

        let mut sum = 0;
        while n > 0 {
            input!(from &mut source, x: u32);
            sum += x;
            n -= 1;
        }
        assert_eq!(sum, 36);
    }

    #[test]
    fn input_with_complex_type() {
        let mut source = AutoSource::from("Hello\n2\n3 1 2 3\n4 5 ab\n4");
        input! {
            from &mut source,
            hello: crate::marker::Bytes,
            from: crate::marker::Usize1,
            vla: [crate::marker::Isize1],
            tuple: (crate::marker::Usize1, crate::marker::Isize1, crate::marker::Chars),
            unit: (crate::marker::Usize1),
        }
        assert_eq!(hello, b"Hello");
        assert_eq!(from, 1);
        assert_eq!(vla, [0, 1, 2]);
        assert_eq!(tuple, (3, 4, vec!['a', 'b']));
        assert_eq!(unit, (3,));
    }

    #[test]
    fn input_single_tt_pattern() {
        let mut source = AutoSource::from("3 42 0\n1 2 3\n");
        input! {
            from &mut source,
            (n, mut k): (usize, usize),
            _: usize,
            xs: [u32; n],
        }
        k += 1;
        assert_eq!(n, 3);
        assert_eq!(k, 43);
        assert_eq!(xs, [1, 2, 3]);
    }

    #[test]
    fn input_generic() {
        enum Array<T, const N: usize> {
            _Phantom(
                std::convert::Infallible,
                std::marker::PhantomData<fn() -> T>,
            ),
        }

        impl<T: crate::source::Readable, const N: usize> crate::source::Readable for Array<T, N> {
            type Output = [T::Output; N];

            fn read<R: std::io::BufRead, S: crate::source::Source<R>>(
                source: &mut S,
            ) -> Self::Output {
                std::array::from_fn(|_| T::read(source))
            }
        }

        let source = AutoSource::from("1 2 3 4 5 6 7 8");

        input! {
            from source,
            a: Array<i32, 5>,
            b: Array<i32, 3>,
        }

        assert_eq!(a, [1, 2, 3, 4, 5]);
        assert_eq!(b, [6, 7, 8]);
    }

    #[test]
    fn read_value_generic() {
        enum Array<T, const N: usize> {
            _Phantom(
                std::convert::Infallible,
                std::marker::PhantomData<fn() -> T>,
            ),
        }

        impl<T: crate::source::Readable, const N: usize> crate::source::Readable for Array<T, N> {
            type Output = [T::Output; N];

            fn read<R: std::io::BufRead, S: crate::source::Source<R>>(
                source: &mut S,
            ) -> Self::Output {
                std::array::from_fn(|_| T::read(source))
            }
        }

        let mut source = AutoSource::from("1 2 3 4 5 6 7 8");

        let a = read_value!(from &mut source, Array<i32, 5>);
        let b = read_value!(from &mut source, Array<i32, 3>);

        assert_eq!(a, [1, 2, 3, 4, 5]);
        assert_eq!(b, [6, 7, 8]);
    }

    #[test]
    fn input_runtime_readable() {
        // VecReadable<T> replicates the built-in Vec reader `input!(v: [T])` in user-land.
        struct VecReadable<T> {
            n: usize,
            _marker: PhantomData<T>,
        }

        impl<T> VecReadable<T> {
            pub fn new(n: usize) -> Self {
                VecReadable {
                    n,
                    _marker: PhantomData,
                }
            }
        }

        impl<T: crate::source::Readable> crate::source::RuntimeReadable for VecReadable<T> {
            type Output = Vec<T::Output>;

            fn read<R: std::io::BufRead, S: crate::source::Source<R>>(
                self,
                source: &mut S,
            ) -> Self::Output {
                let mut res = vec![];
                for _ in 0..self.n {
                    input! {
                        from &mut *source,
                        v: T,
                    }
                    res.push(v);
                }
                res
            }
        }

        let mut source = AutoSource::from("4 1 2 3 4");
        input! {
            from &mut source,
            n: usize,
            v: with VecReadable::<crate::marker::Usize1>::new(n),
        }

        assert_eq!(v, [0, 1, 2, 3]);
    }

    #[test]
    fn read_value_runtime_readable() {
        // VecReadable<T> replicates the built-in Vec reader `input!(v: [T])` in user-land.
        struct VecReadable<T> {
            n: usize,
            _marker: PhantomData<T>,
        }

        impl<T> VecReadable<T> {
            pub fn new(n: usize) -> Self {
                VecReadable {
                    n,
                    _marker: PhantomData,
                }
            }
        }

        impl<T: crate::source::Readable> crate::source::RuntimeReadable for VecReadable<T> {
            type Output = Vec<T::Output>;

            fn read<R: std::io::BufRead, S: crate::source::Source<R>>(
                self,
                source: &mut S,
            ) -> Self::Output {
                let mut res = vec![];
                for _ in 0..self.n {
                    input! {
                        from &mut *source,
                        v: T,
                    }
                    res.push(v);
                }
                res
            }
        }

        let mut source = AutoSource::from("4 1 2 3 4");
        let n = read_value!(from &mut source, usize);
        let v = read_value!(from &mut source, with VecReadable::<crate::marker::Usize1>::new(n));

        assert_eq!(v, [0, 1, 2, 3]);
    }

    #[test]
    #[should_panic]
    fn input_err_different_type() {
        let mut source = AutoSource::from("3.2\n");
        input! {
            from &mut source,
            _n: i32,
        }
    }

    #[test]
    #[should_panic]
    fn input_err_different_format() {
        let mut source = AutoSource::from("");
        input! {
            from &mut source,
            _n: i32,
        }
    }
}