use actix_web::http::StatusCode;
use std::fmt;

pub use export::is_unique_violation;

#[derive(Debug)]
pub enum SpaceError {
    BadRequest(String),
    Unauthorized,
    Forbidden,
    JoinNotAllowed(String),
    JoinRequirementNotMet(String),
    JoinRequestCooldown(String),
    NotFound,
    Conflict(String),
    RateLimited(String),
    Internal(String),
    MalformedRequest,
    InvalidEmail,
    InvalidPermission { permission: String },
    SpaceNotFound,
    SpaceMemberNotFound,
    SpaceRoleNotFound,
    SpaceInviteNotFound,
    SpaceSlugTaken,
    SpaceMemberExists,
    SpaceRoleKeyTaken,
    SpaceRoleInUse,
    SpaceRoleSystem,
    SpaceInviteExhausted,
    SpaceInviteExpired,
    SpaceOwnerRequired,
    SpaceHasMembers,
    SpaceInactive,
    SpaceMemberBanned,
    VersionMismatch { current: i32 },
    UserNotFound,
    ScopeInsufficient { required: String },
}

pub type SpaceResult<T> = Result<T, SpaceError>;

impl fmt::Display for SpaceError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::BadRequest(message) => write!(f, "{message}"),
            Self::Unauthorized => write!(f, "unauthorized"),
            Self::Forbidden => write!(f, "forbidden"),
            Self::JoinNotAllowed(message) => write!(f, "{message}"),
            Self::JoinRequirementNotMet(message) => write!(f, "{message}"),
            Self::JoinRequestCooldown(message) => write!(f, "{message}"),
            Self::NotFound => write!(f, "not found"),
            Self::Conflict(message) => write!(f, "{message}"),
            Self::RateLimited(message) => write!(f, "{message}"),
            Self::Internal(message) => write!(f, "{message}"),
            Self::MalformedRequest => write!(f, "request payload is malformed"),
            Self::InvalidEmail => write!(f, "email is invalid"),
            Self::InvalidPermission { permission } => {
                write!(f, "permission `{permission}` is not recognized")
            }
            Self::SpaceNotFound => write!(f, "space does not exist"),
            Self::SpaceMemberNotFound => write!(f, "space member does not exist"),
            Self::SpaceRoleNotFound => write!(f, "space role does not exist"),
            Self::SpaceInviteNotFound => write!(f, "space invite does not exist"),
            Self::SpaceSlugTaken => write!(f, "space slug is already taken"),
            Self::SpaceMemberExists => write!(f, "user is already a member of this space"),
            Self::SpaceRoleKeyTaken => write!(f, "space role key is already used"),
            Self::SpaceRoleInUse => write!(f, "space role is still assigned to members"),
            Self::SpaceRoleSystem => write!(f, "space role is built in and cannot be modified"),
            Self::SpaceInviteExhausted => write!(f, "space invite is exhausted or revoked"),
            Self::SpaceInviteExpired => write!(f, "space invite has expired"),
            Self::SpaceOwnerRequired => {
                write!(f, "space must have an owner; transfer ownership first")
            }
            Self::SpaceHasMembers => write!(f, "space still has active members"),
            Self::SpaceInactive => write!(f, "space is not active"),
            Self::SpaceMemberBanned => write!(f, "space membership is banned"),
            Self::VersionMismatch { current } => {
                write!(f, "resource version mismatch, current version is {current}")
            }
            Self::UserNotFound => write!(f, "user does not exist"),
            Self::ScopeInsufficient { required } => write!(f, "scope `{required}` is missing"),
        }
    }
}

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

impl From<deletion::DeletionError> for SpaceError {
    fn from(error: deletion::DeletionError) -> Self {
        use deletion::DeletionError;
        match error {
            DeletionError::Database(error) => Self::from(error),
            DeletionError::Conflict(message) => Self::Conflict(message),
            DeletionError::NotFound(message) => {
                tracing::debug!(%message, "deletion target not found");
                Self::NotFound
            }
            DeletionError::KenAuth(message)
            | DeletionError::KenShell(message)
            | DeletionError::Config(message) => Self::Internal(message),
        }
    }
}

impl From<session::SessionError> for SpaceError {
    fn from(_: session::SessionError) -> Self {
        Self::Unauthorized
    }
}

impl From<export::KenAuthError> for SpaceError {
    fn from(error: export::KenAuthError) -> Self {
        match error {
            export::KenAuthError::NotFound => Self::NotFound,
            export::KenAuthError::Unauthenticated => Self::Unauthorized,
            export::KenAuthError::Unavailable(message) => {
                Self::Internal(format!("kenoauth unavailable: {message}"))
            }
            export::KenAuthError::Rejected(message) => {
                let lower = message.to_lowercase();
                if lower.contains("already") || lower.contains("taken") {
                    Self::Conflict(message)
                } else if lower.contains("forbidden") || lower.contains("permission") {
                    Self::Forbidden
                } else {
                    Self::BadRequest(message)
                }
            }
            export::KenAuthError::Config(message) | export::KenAuthError::Internal(message) => {
                Self::Internal(message)
            }
        }
    }
}

export::db_error_conversions!(SpaceError);
export::storage_error_conversion!(SpaceError);
export::export_error_conversion!(SpaceError);
export::json_payload_conversion!(SpaceError);

export::api_error! {
    log: "space",
    pub enum ApiError {
        BadRequest(400, "request failed validation"),
        Unauthorized(401, "authentication required"),
        Forbidden(403, "operation not allowed"),
        NotFound(404, "resource not found"),
        Conflict(409, "resource conflict"),
        TooManyRequests(429, "rate limit exceeded"),
        PreconditionFailed(412, "precondition failed"),
        Internal(500, "internal server error"),
    }
}

impl From<SpaceError> for ApiError {
    fn from(error: SpaceError) -> Self {
        let status = error.status_code().as_u16();
        if error.is_internal() {
            tracing::warn!(%error, "space handler failed");
        }
        Self::build(
            status,
            export::rest::AppResponseData::err(i32::from(status), error.message())
                .with_error_code(error.code()),
        )
    }
}

impl SpaceError {
    pub fn internal(message: impl Into<String>) -> Self {
        Self::Internal(message.into())
    }

    pub fn status_code(&self) -> StatusCode {
        match self {
            Self::Unauthorized => StatusCode::UNAUTHORIZED,
            Self::Forbidden
            | Self::JoinNotAllowed(_)
            | Self::JoinRequirementNotMet(_)
            | Self::JoinRequestCooldown(_)
            | Self::SpaceInactive
            | Self::SpaceMemberBanned
            | Self::ScopeInsufficient { .. } => StatusCode::FORBIDDEN,
            Self::NotFound
            | Self::SpaceNotFound
            | Self::SpaceMemberNotFound
            | Self::SpaceRoleNotFound
            | Self::SpaceInviteNotFound
            | Self::UserNotFound => StatusCode::NOT_FOUND,
            Self::Conflict(_)
            | Self::SpaceSlugTaken
            | Self::SpaceMemberExists
            | Self::SpaceRoleKeyTaken
            | Self::SpaceHasMembers
            | Self::VersionMismatch { .. } => StatusCode::CONFLICT,
            Self::SpaceRoleInUse
            | Self::SpaceRoleSystem
            | Self::SpaceInviteExhausted
            | Self::SpaceInviteExpired
            | Self::SpaceOwnerRequired => StatusCode::PRECONDITION_FAILED,
            Self::RateLimited(_) => StatusCode::TOO_MANY_REQUESTS,
            Self::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
            Self::BadRequest(_)
            | Self::MalformedRequest
            | Self::InvalidEmail
            | Self::InvalidPermission { .. } => StatusCode::BAD_REQUEST,
        }
    }

    pub fn code(&self) -> &'static str {
        match self {
            Self::BadRequest(_) => "bad_request",
            Self::Unauthorized => "unauthorized",
            Self::Forbidden => "forbidden",
            Self::JoinNotAllowed(_) => "join_not_allowed",
            Self::JoinRequirementNotMet(_) => "join_requirement_not_met",
            Self::JoinRequestCooldown(_) => "join_request_cooldown",
            Self::NotFound => "not_found",
            Self::Conflict(_) => "conflict",
            Self::RateLimited(_) => "rate_limited",
            Self::Internal(_) => "internal",
            Self::MalformedRequest => "malformed_request",
            Self::InvalidEmail => "invalid_email",
            Self::InvalidPermission { .. } => "invalid_permission",
            Self::SpaceNotFound => "space_not_found",
            Self::SpaceMemberNotFound => "space_member_not_found",
            Self::SpaceRoleNotFound => "space_role_not_found",
            Self::SpaceInviteNotFound => "space_invite_not_found",
            Self::SpaceSlugTaken => "space_slug_taken",
            Self::SpaceMemberExists => "space_member_exists",
            Self::SpaceRoleKeyTaken => "space_role_key_taken",
            Self::SpaceRoleInUse => "space_role_in_use",
            Self::SpaceRoleSystem => "space_role_system",
            Self::SpaceInviteExhausted => "space_invite_exhausted",
            Self::SpaceInviteExpired => "space_invite_expired",
            Self::SpaceOwnerRequired => "space_owner_required",
            Self::SpaceHasMembers => "space_has_members",
            Self::SpaceInactive => "space_inactive",
            Self::SpaceMemberBanned => "space_member_banned",
            Self::VersionMismatch { .. } => "version_mismatch",
            Self::UserNotFound => "user_not_found",
            Self::ScopeInsufficient { .. } => "scope_insufficient",
        }
    }

    pub fn is_internal(&self) -> bool {
        self.status_code().is_server_error()
    }

    pub fn message(&self) -> String {
        if self.is_internal() {
            "internal server error".to_string()
        } else {
            self.to_string()
        }
    }
}

export::access_error_conversion!(SpaceError, BadRequest);