use std::{
    fmt::{Debug, FormattingOptions},
    ops::Deref,
};

use crate::lexer::Token;
use beef::lean::Cow;
use chumsky::{
    input::{MappedInput, Stream},
    prelude::*,
};
pub type Span = SimpleSpan<usize>;
pub type Error<'s> = Rich<'s, Token<'s>, Span>;
pub type Input<'s> = MappedInput<
    Token<'s>,
    Span,
    Stream<crate::lexer::Lexer<'s>>,
    fn((Token<'_>, SimpleSpan)) -> (Token<'_>, SimpleSpan),
>;

#[derive(Debug)]
pub enum Ast<'s> {
    Module(Vec<Expr<'s>>),
}

#[derive(Clone, Default)]
pub struct Λ<'s>(pub Vec<Expr<'s>>);
impl std::fmt::Debug for Λ<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match &*self.0 {
            [] => write!(f, "λ()"),
            [a] => f.write_fmt(format_args!("λ({a:?})")),
            x => {
                if x.len() < 5 {
                    f.write_fmt(format_args!("λ({x:?})"))
                } else {
                    write!(f, "λ")?;
                    f.with_options(*FormattingOptions::new().alternate(true))
                        .debug_list()
                        .entries(&self.0)
                        .finish()
                }
            }
        }
    }
}

#[derive(Clone)]
pub enum Value<'s> {
    Float(f64),
    Int(u64),
    String(Cow<'s, str>),
    Unit,
}

impl std::fmt::Debug for Value<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Float(x) => write!(f, "{x}"),
            Self::Int(x) => write!(f, "{x}"),
            Self::String(x) => write!(f, "\"{x}\""),
            Self::Unit => write!(f, "()"),
        }
    }
}

impl std::fmt::Debug for Expr<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::NoOp => write!(f, "nop"),
            Self::Function(x) => x.fmt(f),
            Self::Value(x) => x.fmt(f),
            Self::Ident(x) => x.fmt(f),
            Self::Lambda(x) => x.fmt(f),
            Self::Let { name, rhs } => write!(f, "let({rhs:?} -> {name})"),
        }
    }
}
#[derive(Clone)]
pub enum Expr<'s> {
    NoOp,
    Function(super::fun::Function<'s>),
    Value(Value<'s>),
    Ident(&'s str),
    Lambda(Λ<'s>),
    Let { name: &'s str, rhs: Box<Expr<'s>> },
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct Spanned<T> {
    pub inner: T,
    pub span: Span,
}

impl<T> Deref for Spanned<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<T> Spanned<T> {
    pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Spanned<U> {
        Spanned {
            inner: f(self.inner),
            span: self.span,
        }
    }

    pub fn dummy(inner: T) -> Spanned<T> {
        Spanned {
            inner,
            span: SimpleSpan::new((), 0..0),
        }
    }

    pub fn copys<U>(&self, with: U) -> Spanned<U> {
        Spanned {
            inner: with,
            span: self.span,
        }
    }
}

impl<T> From<(T, Span)> for Spanned<T> {
    fn from((inner, span): (T, Span)) -> Self {
        Self { inner, span }
    }
}

impl<T: std::fmt::Display> std::fmt::Display for Spanned<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.inner)
    }
}

#[derive(Clone)]
pub enum Type<'s> {
    Tuple(Box<[Type<'s>]>),
    Path(&'s str),
    Unit,
}

impl std::fmt::Debug for Type<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Tuple(x) => write!(
                f,
                "{}",
                std::iter::once("(".to_string())
                    .chain(x.iter().map(|x| format!("{x:?}")).intersperse(", ".into()),)
                    .chain([")".to_string()])
                    .reduce(|acc, x| acc + &x)
                    .unwrap()
            ),
            Self::Path(x) => write!(f, "{x}"),
            Self::Unit => write!(f, "()"),
        }
    }
}