#![allow(clippy::blocks_in_conditions)]

use std::ops::Deref;

pub mod model;

#[cfg(feature = "rowing-tera")]
pub mod tera;

#[cfg(feature = "rest")]
pub mod rest;

pub mod scheduled;

pub(crate) const AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD: i64 = 10;
pub(crate) const RENNRUDERBEITRAG: i64 = 11000;
pub(crate) const BOAT_STORAGE: i64 = 4500;
pub(crate) const FAMILY_TWO: i64 = 30000;
pub(crate) const FAMILY_THREE_OR_MORE: i64 = 35000;
pub(crate) const STUDENT_OR_PUPIL: i64 = 8000;
pub(crate) const REGULAR: i64 = 22000;
pub(crate) const UNTERSTUETZEND: i64 = 2500;
pub(crate) const FOERDERND: i64 = 8500;
pub(crate) const SCHECKBUCH: i64 = 3000;
pub(crate) const EINSCHREIBGEBUEHR: i64 = 3000;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NonEmptyString(String);

impl NonEmptyString {
    pub fn new(s: String) -> Option<Self> {
        if s.is_empty() {
            None
        } else {
            Some(NonEmptyString(s))
        }
    }

    pub fn as_str(&self) -> &str {
        &self.0
    }

    pub fn into_string(self) -> String {
        self.0
    }
}

// Implement Deref to allow automatic dereferencing to &str
impl Deref for NonEmptyString {
    type Target = str;

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

// This allows &NonEmptyString to be converted to &str
impl AsRef<str> for NonEmptyString {
    fn as_ref(&self) -> &str {
        &self.0
    }
}

// This allows NonEmptyString to be converted to String with .into()
impl From<NonEmptyString> for String {
    fn from(s: NonEmptyString) -> Self {
        s.0
    }
}

impl TryFrom<&str> for NonEmptyString {
    type Error = &'static str;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        if s.is_empty() {
            Err("String cannot be empty")
        } else {
            Ok(NonEmptyString(s.to_string()))
        }
    }
}

impl TryFrom<String> for NonEmptyString {
    type Error = &'static str;

    fn try_from(s: String) -> Result<Self, Self::Error> {
        if s.is_empty() {
            Err("String cannot be empty")
        } else {
            Ok(NonEmptyString(s))
        }
    }
}

#[cfg(test)]
#[macro_export]
macro_rules! testdb {
    () => {{
        let pool = SqlitePool::connect(":memory:").await.unwrap();
        sqlx::query_file!("./migration.sql")
            .execute(&pool)
            .await
            .unwrap();
        sqlx::query_file!("./seeds.sql")
            .execute(&pool)
            .await
            .unwrap();
        pool
    }};
}