use std::fmt;

use serde::{Deserialize, Serialize};
use utoipa::{IntoParams, ToSchema};

pub const DEFAULT_PAGE_LIMIT: u64 = 50;
pub const MAX_PAGE_LIMIT: u64 = 100;
pub const MAX_OFFSET: u64 = 5000;

#[derive(Debug, Clone, Copy, Default, Deserialize, IntoParams, ToSchema)]
#[serde(deny_unknown_fields)]
pub struct PageQuery {
    pub limit: Option<u64>,
    pub offset: Option<u64>,
}

impl PageQuery {
    pub fn resolve(&self, default: u64, max: u64) -> Result<(u64, u64), PageError> {
        resolve_bounds(self.limit, self.offset, default, max)
    }

    pub fn bounds(&self) -> Result<(u64, u64), PageError> {
        self.resolve(DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT)
    }
}

pub fn page_bounds(
    limit: Option<u64>,
    offset: Option<u64>,
    default: u64,
    max: u64,
) -> Result<(u64, u64), PageError> {
    resolve_bounds(limit, offset, default, max)
}

fn resolve_bounds(
    limit: Option<u64>,
    offset: Option<u64>,
    default: u64,
    max: u64,
) -> Result<(u64, u64), PageError> {
    let limit = limit.unwrap_or(default);
    if limit == 0 || limit > max {
        return Err(PageError(format!("limit must be between 1 and {max}")));
    }
    let offset = offset.unwrap_or(0);
    if offset > MAX_OFFSET {
        return Err(PageError(format!("offset must not exceed {MAX_OFFSET}")));
    }
    Ok((limit, offset))
}

#[derive(Debug, Clone)]
pub struct PageError(String);

impl PageError {
    pub fn message(&self) -> &str {
        &self.0
    }
}

impl fmt::Display for PageError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(&self.0)
    }
}

impl std::error::Error for PageError {}

#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct Page<T> {
    pub items: Vec<T>,
    pub total: u64,
    pub limit: u64,
    pub offset: u64,
}

impl<T> Page<T> {
    pub fn new(items: Vec<T>, total: u64, limit: u64, offset: u64) -> Self {
        Self {
            items,
            total,
            limit,
            offset,
        }
    }
}

pub fn paginate<T>(items: Vec<T>, page: &PageQuery) -> Result<Page<T>, PageError> {
    let (limit, offset) = page.bounds()?;
    let total = items.len() as u64;
    let items = items
        .into_iter()
        .skip(offset as usize)
        .take(limit as usize)
        .collect();
    Ok(Page {
        items,
        total,
        limit,
        offset,
    })
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, ToSchema)]
#[serde(rename_all = "snake_case")]
pub enum SortOrder {
    Asc,
    Desc,
}

impl SortOrder {
    pub fn is_desc(self) -> bool {
        matches!(self, Self::Desc)
    }
}