use chrono::{naive::NaiveDate, Duration};

use crate::transaction::{Category, Transaction};

pub struct Search<'t> {
    filtered: Vec<usize>,
    transactions: Vec<&'t Transaction>,
}

pub enum DateFilter {
    Absolute {
        start: Option<NaiveDate>,
        end: Option<NaiveDate>,
    },
    Relative {
        start: Option<Duration>,
        end: Option<Duration>,
    }
}

pub enum Constraint {
    Category(Category),
    Date(DateFilter),
}

impl Constraint {
    fn satisfies(&self, t: &Transaction) -> bool {
        match self {
            Constraint::Category(category) => category == &t.category,
            Constraint::Date(_) => todo!(),
        }
    }
}

impl<'t> Search<'t> {
    pub fn new(transactions: Vec<&'t Transaction>) -> Self {
        Self {
            filtered: std::iter::successors(Some(0_usize), |n| Some(n.checked_add(1).unwrap())).take(transactions.len()).collect(),
            transactions,
        }
    }

    pub fn get(&self) -> Vec<&'t Transaction> {
        self
            .filtered
            .iter()
            .map(|idx| self.transactions[*idx])
            .collect()
    }

    pub fn subtract(self, constraint: Constraint) -> Self {
        Self {
            filtered: self
                .filtered
                .iter()
                .copied()
                .filter(|idx| !constraint.satisfies(self.transactions[*idx]))
                .collect(),
            transactions: self.transactions,
        }
    }
}