use std::fmt;
use std::num::NonZeroU8;

mod sealed {
    pub trait Sealed {}
}

pub trait Stage: sealed::Sealed {}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Draft;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Verified;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Live;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Canary {
    traffic: TrafficPercent,
}

impl sealed::Sealed for Draft {}
impl sealed::Sealed for Verified {}
impl sealed::Sealed for Canary {}
impl sealed::Sealed for Live {}
impl Stage for Draft {}
impl Stage for Verified {}
impl Stage for Canary {}
impl Stage for Live {}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(transparent)]
pub struct TrafficPercent(NonZeroU8);

impl TrafficPercent {
    /// Liefert den Prozentwert als `u8` (garantiert zwischen 1 und 100).
    pub fn get(self) -> u8 {
        self.0.get()
    }

    /// Liefert den darunterliegenden `NonZeroU8`.
    pub fn get_nonzero(self) -> NonZeroU8 {
        self.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InvalidTrafficPercent(pub u8);

impl fmt::Display for InvalidTrafficPercent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "traffic percent must be between 1 and 100, got {}",
            self.0
        )
    }
}

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

impl TryFrom<u8> for TrafficPercent {
    type Error = InvalidTrafficPercent;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        let value = NonZeroU8::new(value).ok_or(InvalidTrafficPercent(0))?;
        (value.get() <= 100)
            .then_some(Self(value))
            .ok_or(InvalidTrafficPercent(value.get()))
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GateReport {
    failures: u32,
}

impl GateReport {
    pub(crate) fn new(failures: u32) -> Self {
        Self { failures }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Rejected {
    pub failures: u32,
}

pub trait Deployer {
    type Error;
    fn start_canary(&mut self, artifact: &str, traffic: TrafficPercent) -> Result<(), Self::Error>;
    fn promote(&mut self, artifact: &str) -> Result<(), Self::Error>;
    fn abort(&mut self, artifact: &str) -> Result<(), Self::Error>;
}

#[derive(Debug)]
#[must_use = "dropping a release discards its typestate"]
pub struct Release<S: Stage> {
    artifact: String,
    stage: S,
}

#[derive(Debug)]
pub struct TransitionError<S: Stage, E> {
    pub release: Release<S>, // failed transition preserves the valid state
    pub source: E,
}

impl<S: Stage, E: fmt::Display> fmt::Display for TransitionError<S, E> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "stage transition failed: {}", self.source)
    }
}

impl<S: Stage + fmt::Debug, E: std::error::Error + 'static> std::error::Error
    for TransitionError<S, E>
{
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(&self.source)
    }
}

impl<S: Stage> Release<S> {
    fn into_stage<T: Stage>(self, stage: T) -> Release<T> {
        Release {
            artifact: self.artifact,
            stage,
        }
    }
}

impl Release<Draft> {
    pub fn new(artifact: impl Into<String>) -> Self {
        Self {
            artifact: artifact.into(),
            stage: Draft,
        }
    }

    pub fn verify(self, gates: &GateReport) -> Result<Release<Verified>, Rejected> {
        match gates.failures {
            0 => Ok(self.into_stage(Verified)),
            failures => Err(Rejected { failures }),
        }
    }
}

impl Release<Verified> {
    pub fn canary<D: Deployer>(
        self,
        deployer: &mut D,
        traffic: TrafficPercent,
    ) -> Result<Release<Canary>, TransitionError<Verified, D::Error>> {
        match deployer.start_canary(&self.artifact, traffic) {
            Ok(()) => Ok(self.into_stage(Canary { traffic })),
            Err(source) => Err(TransitionError {
                release: self,
                source,
            }),
        }
    }
}

impl Release<Canary> {
    pub fn traffic(&self) -> TrafficPercent {
        self.stage.traffic
    }

    pub fn promote<D: Deployer>(
        self,
        deployer: &mut D,
    ) -> Result<Release<Live>, TransitionError<Canary, D::Error>> {
        match deployer.promote(&self.artifact) {
            Ok(()) => Ok(self.into_stage(Live)),
            Err(source) => Err(TransitionError {
                release: self,
                source,
            }),
        }
    }

    pub fn abort<D: Deployer>(
        self,
        deployer: &mut D,
    ) -> Result<Release<Draft>, TransitionError<Canary, D::Error>> {
        match deployer.abort(&self.artifact) {
            Ok(()) => Ok(self.into_stage(Draft)),
            Err(source) => Err(TransitionError {
                release: self,
                source,
            }),
        }
    }
}

impl Release<Live> {
    pub fn artifact(&self) -> &str {
        &self.artifact
    }
}