use crate::buffer::BufferID;
use crate::selection::{Interval, Selection, VectoriseError};
use crate::state::EditorState;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum SFError {}

struct SFComponents {
    niladic: Box<dyn Fn(&EditorState) -> Result<Selection, SFError>>,
    monadic_rank0: Box<dyn Fn(&EditorState, &BufferID, usize) -> Result<Selection, SFError>>,
    monadic_rank1: Box<dyn Fn(&EditorState, &BufferID, &Interval) -> Result<Selection, SFError>>,
    dyadic: Option<Box<dyn Fn(&EditorState, &Selection, &Selection) -> Result<Selection, SFError>>>,
}

pub struct SelectionFunction<E> {
    niladic: Box<dyn Fn(&EditorState) -> Result<Selection, E>>,
    monadic: Box<dyn Fn(&EditorState, &Selection) -> Result<Selection, E>>,
    dyadic: Option<Box<dyn Fn(&EditorState, &Selection, &Selection) -> Result<Selection, E>>>,
}

impl From<SFComponents> for SelectionFunction<VectoriseError<SFError>> {
    fn from(sfc: SFComponents) -> Self {
        let dyadic: Option<Box<dyn Fn(&EditorState, &Selection, &Selection) -> _>> =
            if let Some(func) = sfc.dyadic {
                Some(Box::new(
                    move |editor_state: &EditorState, left: &Selection, right: &Selection| {
                        (func)(editor_state, left, right).map_err(VectoriseError::ProcessingError)
                    },
                ))
            } else {
                None
            };

        Self {
            niladic: Box::new(move |editor_state: &EditorState| {
                (sfc.niladic)(editor_state).map_err(VectoriseError::ProcessingError)
            }),
            monadic: Box::new(Selection::vectorise(sfc.monadic_rank0, sfc.monadic_rank1)),
            dyadic: dyadic,
        }
    }
}