use itemize::TryIntoItems;

#[derive(Debug)]
struct ParseError(String);

impl From<std::num::ParseIntError> for ParseError {
    fn from(e: std::num::ParseIntError) -> Self {
        ParseError(e.to_string())
    }
}

#[derive(TryIntoItems)]
#[items_from(
    types(String, &'a str, i64),
    tuples(3),
    collections(vec, slice, array),
    error_type(ParseError)
)]
struct Int(i64);

impl TryFrom<&str> for Int {
    type Error = std::num::ParseIntError;
    fn try_from(s: &str) -> Result<Self, Self::Error> {
        s.parse::<i64>().map(Int)
    }
}

impl TryFrom<String> for Int {
    type Error = std::num::ParseIntError;
    fn try_from(s: String) -> Result<Self, Self::Error> {
        s.parse::<i64>().map(Int)
    }
}

impl TryFrom<i64> for Int {
    type Error = std::num::ParseIntError;
    fn try_from(n: i64) -> Result<Self, Self::Error> {
        Ok(Int(n))
    }
}

fn parse_ints(input: impl TryIntoItems<Int, ParseError>) -> Result<Vec<Int>, ParseError> {
    input.try_into_items().collect()
}

fn main() -> Result<(), ParseError> {
    let _ = parse_ints("42")?;
    let _ = parse_ints(("1", "2".to_string(), 3))?;
    let _ = parse_ints(["10", "20", "30"])?;
    let _ = parse_ints(vec!["100", "200"])?;
    Ok(())
}

use itemize::IntoItems;

#[derive(Debug, IntoItems)]
#[items_from(types(u32), tuples(2), collections(vec, array))]
struct Count(u32);

impl From<u32> for Count {
    fn from(value: u32) -> Self {
        Count(value)
    }
}

fn collect_counts(input: impl IntoItems<Count>) -> Vec<u32> {
    input.into_items().map(|Count(n)| n).collect()
}

fn main() {
    let single = collect_counts(5);
    let mixed = collect_counts((vec![1, 2], [3, 4]));
    assert_eq!(single, vec![5]);
    assert_eq!(mixed, vec![1, 2, 3, 4]);
}

use itemize::IntoRows;

#[derive(Debug, IntoRows)]
#[items_from(types(&'a str), tuples(2), collections(vec, array))]
struct Cell<'a>(&'a str);

impl<'a> From<&'a str> for Cell<'a> {
    fn from(value: &'a str) -> Self {
        Cell(value)
    }
}

fn collect_rows<'a>(input: impl IntoRows<Cell<'a>>) -> Vec<Vec<&'a str>> {
    input
        .into_rows()
        .map(|row| row.map(|Cell(value)| value).collect())
        .collect()
}

fn main() {
    let grid = collect_rows((vec!["a", "b"], ["c", "d", "e"]));
    assert_eq!(grid, vec![vec!["a", "b"], vec!["c", "d", "e"]]);
}