use crate::tasks::{Task, TaskPayload, TaskStatus};
use futures::{Stream};
mod sqlite;

#[derive(Default, Clone)]
pub struct TaskPagination {
    page_size: usize,
    limit: Option<u32>,
    offset: Option<u32>,
    status: Option<TaskStatus>,
}

impl TaskPagination {
    pub fn new() -> Self {
        Self::default()
    }
    
    pub fn next(&self) -> Self {
       Self {
            page_size: self.page_size + self.page_size,
           ..self.clone()
       } 
    }

    pub fn prev(&self) -> Self {
        Self {
            page_size: self.page_size - self.page_size,
            ..self.clone()
        }
    }

    pub fn set_page_size(&mut self, page_size: usize) {
        self.page_size = page_size;
    }

    pub fn set_limit(&mut self, limit: Option<u32>) {
        self.limit = limit;
    }

    pub fn set_offset(&mut self, offset: Option<u32>) {
        self.offset = offset;
    }

    pub fn set_status(&mut self, status: Option<TaskStatus>) {
        self.status = status;
    }
}

pub struct TasksPage<T: TaskPayload> {
   tasks: Vec<Task<T>>, 
    page: TaskPagination
}

impl<T: TaskPayload> TasksPage<T> {
    fn new(tasks: Vec<Task<T>>, page: TaskPagination) -> Self {
       Self {
           tasks,
           page
       } 
    }

    pub fn next(&self) -> TaskPagination {
       self.page.next() 
    }

    pub fn prev(&self) -> TaskPagination {
        self.page.prev()
    }
}

pub trait TaskStorage<T: TaskPayload> {
    async fn insert_tasks<'a, I: IntoIterator<Item=&'a Task<T>>>(&self, tasks: I) -> crate::Result<()>;
    fn get_tasks(&self, options: TaskStatus) -> impl Stream<Item = crate::Result<Task<T>>>;

    async fn get_paginated_tasks(&self, page: &TaskPagination) -> crate::Result<TasksPage<T>>;
}