use std::{fmt::Display, str::FromStr};

use crate::split;

use super::parser::{FromStrings, ParseError};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Pad {
    Unchanged,
    Up(u32),
    UpRight(u32, u32),
    UpRightDown(u32, u32, u32),
    UpRightDownLeft(u32, u32, u32, u32),
}

impl FromStrings for Pad {
    fn from_strings<I: Iterator<Item = String>>(s: I) -> Result<Self, ParseError> {
        let parts = s.collect::<Vec<_>>();
        match parts.len() {
            0 => Err(ParseError::Empty),
            1 => Ok(Pad::Up(parts[0].parse()?)),
            2 => Ok(Pad::UpRight(parts[0].parse()?, parts[1].parse()?)),
            3 => Ok(Pad::UpRightDown(
                parts[0].parse()?,
                parts[1].parse()?,
                parts[2].parse()?,
            )),
            _ => Ok(Pad::UpRightDownLeft(
                parts[0].parse()?,
                parts[1].parse()?,
                parts[2].parse()?,
                parts[3].parse()?,
            )),
        }
    }
}

impl FromStr for Pad {
    type Err = ParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts = split::tab_or_space(s);
        Self::from_strings(parts.into_iter())
    }
}

impl Display for Pad {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Pad::Unchanged => Ok(()),
            Pad::Up(up) => f.write_str(&up.to_string()),
            Pad::UpRight(up, right) => write!(f, "{up}\t{right}"),
            Pad::UpRightDown(up, right, down) => write!(f, "{up}\t{right}\t{down}"),
            Pad::UpRightDownLeft(up, right, down, left) => {
                write!(f, "{up}\t{right}\t{down}\t{left}")
            }
        }
    }
}

impl Default for Pad {
    fn default() -> Self {
        Pad::Unchanged
    }
}