use std::borrow::Cow;

use axum::Json;
use serde::Serialize;

use super::AppError;

#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ApiResponse<T> {
    #[serde(rename = "_meta")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta: Option<ApiResponseMetadata>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<T>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<Cow<'static, str>>,
}

impl<T> ApiResponse<T> {
    pub fn new(data: T) -> ApiResponse<T> {
        Self {
            meta: None,
            data: Some(data),
            error: None,
        }
    }

    pub fn _new_with_metadata(data: T, meta: ApiResponseMetadata) -> ApiResponse<T> {
        Self {
            meta: Some(meta),
            data: Some(data),
            error: None,
        }
    }

    pub fn into_json_response(self) -> Json<ApiResponse<T>> {
        Json(self)
    }
}

impl ApiResponse<()> {
    pub fn _new_empty() -> Self {
        Self {
            meta: None,
            data: None,
            error: None,
        }
    }

    pub fn error(error: &'static str) -> Self {
        Self {
            meta: None,
            data: None,
            error: Some(error.into()),
        }
    }

    pub fn new_with_error(error: AppError) -> Self {
        Self {
            meta: None,
            data: None,
            error: Some(error.to_string().into()),
        }
    }
}

#[derive(Clone, Debug, Serialize)]
pub struct ApiResponseMetadata {}