jelq

use axum::http::StatusCode;

use crate::problem::Problem;

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum Cause {

    Ruptured { ice_unused: bool },

    Caught,

    Opened,

    Banned,

    Degloved,

    Zip,

    Meloned,

    Overstayed,

    Abandoned,

    Lost,

}

impl Cause {

    pub const ALL: [Self; 11] = [

        Self::Ruptured { ice_unused: true },

        Self::Ruptured { ice_unused: false },

        Self::Caught,

        Self::Opened,

        Self::Banned,

        Self::Degloved,

        Self::Zip,

        Self::Meloned,

        Self::Overstayed,

        Self::Abandoned,

        Self::Lost,

    ];

    pub fn slug(self) -> &'static str {

        match self {

            Self::Ruptured { .. } => "ruptured",

            Self::Caught => "caught",

            Self::Opened => "opened",

            Self::Banned => "banned",

            Self::Degloved => "degloved",

            Self::Zip => "zip",

            Self::Meloned => "watermelon",

            Self::Overstayed => "overstayed",

            Self::Abandoned => "abandoned",

            Self::Lost => "lost",

        }

    }

    pub fn detail(self) -> &'static str {

        match self {

            Self::Ruptured { ice_unused: true } => {

                "A vessel has exceeded its rated pressure. The run has ended. An ice pack was available and was not used."

            }

            Self::Ruptured { ice_unused: false } => {

                "A vessel has exceeded its rated pressure. The run has ended."

            }

            Self::Caught => {

                "Mum has seen enough. The run has ended. Nobody will mention it at dinner."

            }

            Self::Opened => {

                "Mum has stopped knocking and opened the door. The run has ended. Nobody will mention it at dinner."

            }

            Self::Banned => "Your account has been banned. The forum can tell. The run has ended.",

            Self::Degloved => {

                "The outer layer has been removed in one piece. It will not be returning. The run has ended."

            }

            Self::Zip => {

                "The request conflicts with the current state of the zip. The run has ended."

            }

            Self::Meloned => {

                "You have been caught with the watermelon. Nobody will mention it at dinner. The run has ended."

            }

            Self::Overstayed => {

                "The floor ran long and somebody walked in. The run has ended. Nobody will mention it at dinner."

            }

            Self::Abandoned => "The run was abandoned.",

            Self::Lost => {

                "The server fell over mid-stroke and the run went with it. Nobody will mention it at dinner."

            }

        }

    }

    /// The records keep the slug and the ice, which is all a cause needs to be told again.

    pub fn parse(slug: &str, ice_unused: bool) -> Option<Self> {

        Self::ALL.into_iter().find(|cause| {

            cause.slug() == slug

                && !matches!(cause, Self::Ruptured { ice_unused: unused } if *unused != ice_unused)

        })

    }

    fn status(self) -> StatusCode {

        match self {

            Self::Ruptured { .. } | Self::Lost => StatusCode::INTERNAL_SERVER_ERROR,

            Self::Caught

            | Self::Opened

            | Self::Degloved

            | Self::Abandoned

            | Self::Meloned

            | Self::Overstayed => StatusCode::GONE,

            Self::Banned => StatusCode::FORBIDDEN,

            Self::Zip => StatusCode::CONFLICT,

        }

    }

    pub fn problem(self) -> Problem {

        Problem::new(self.status(), self.slug(), self.detail())

    }

}

pub struct Ending {

    pub(crate) cause: Cause,

    pub(crate) turn: u32,

}

#[derive(Clone, Copy, PartialEq, Eq, Debug)]

pub enum RunStatus {

    Alive,

    Prescribed,

    /// The true ending, the clinic's `304`.

    Normal,

    Gone,

}

impl RunStatus {

    pub const ALL: [Self; 4] = [Self::Alive, Self::Prescribed, Self::Normal, Self::Gone];

    pub fn name(self) -> &'static str {

        match self {

            Self::Alive => "alive",

            Self::Prescribed => "prescribed",

            Self::Normal => "normal",

            Self::Gone => "gone",

        }

    }

    pub fn parse(name: &str) -> Option<Self> {

        Self::ALL.into_iter().find(|status| status.name() == name)

    }

    pub fn finished(self) -> bool {

        self != Self::Alive

    }

}