hgame 0.26.4

use super::*;
#[cfg(feature = "gui")]
use hconf::palette::{Palette, Rgb};

// ----------------------------------------------------------------------------
#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    Hash,
    strum::AsRefStr,
    strum::EnumIter,
    PartialOrd,
    std::cmp::Ord,
)]
/// Status of a [`ProductionAsset`].
pub enum AssetStatus {
    #[strum(serialize = "Not Started")]
    NotStarted,

    #[strum(serialize = "No Brief")]
    NoBrief,

    Blocking,

    Model,

    #[strum(serialize = "UV")]
    Uv,

    Texture,

    #[strum(serialize = "LOD")]
    Lod,

    Rig,

    #[strum(serialize = "AD Feedback")]
    AdFeedback,

    #[strum(serialize = "Feedback Addressed")]
    FeedbackAddressed,

    #[strum(serialize = "Submit for Review")]
    SubmitForReview,

    #[strum(serialize = "QC Approved")]
    QcApproved,

    #[strum(serialize = "AD Approved")]
    AdApproved,

    #[strum(serialize = "Pending Feedback")]
    PendingFeedback,

    #[strum(serialize = "Client Feedback")]
    ClientFeedback,

    #[strum(serialize = "Client Approved")]
    ClientApproved,

    _Omitted,

    #[strum(serialize = "On Hold")]
    _OnHold,

    #[strum(serialize = "For Review")]
    _ForReview,

    #[strum(serialize = "Temp Published")]
    _TempPublished,

    #[strum(serialize = "Anim Published")]
    _AnimPublished,

    #[strum(serialize = "Render Published")]
    _RenderPublished,

    #[strum(serialize = "Client Published")]
    _ClientPublished,

    Undefined,
}

impl AssetStatus {
    pub fn all() -> BTreeSet<Self> {
        Self::iter().collect()
    }

    #[cfg(feature = "gui")]
    fn color_rgb<'a>(&self, palette: &'a Palette) -> &'a Rgb {
        let p = &palette.dark;
        match self {
            Self::NotStarted => &p.rgb.INITIAL1,
            Self::NoBrief => &p.rgb.INITIAL1,
            Self::Blocking => &p.rgb.WIP1,
            Self::Model => &p.rgb.WIP2,
            Self::Uv => &p.rgb.WIP3,
            Self::Texture => &p.rgb.WIP4,
            Self::Lod => &p.rgb.WIP5,
            Self::Rig => &p.rgb.WIP6,
            Self::AdFeedback => &p.rgb.REVIEWA1,
            Self::FeedbackAddressed => &p.rgb.REVIEWA2,
            Self::SubmitForReview => &p.rgb.REVIEWA3,
            Self::QcApproved => &p.rgb.REVIEWB1,
            Self::AdApproved => &p.rgb.REVIEWB2,
            Self::PendingFeedback => &p.rgb.REVIEWB3,
            Self::ClientFeedback => &p.rgb.REVIEWB4,
            Self::ClientApproved => &p.rgb.REVIEWB5,
            Self::_Omitted => &p.rgb.INITIAL2,
            Self::_OnHold => &p.rgb.INITIAL3,
            Self::_ForReview => &p.rgb.REVIEWA4,
            Self::_TempPublished => &palette.common.rgb.LIGHT_GRAY,
            Self::_AnimPublished => &p.rgb.PUBLISH1,
            Self::_RenderPublished => &p.rgb.PUBLISH2,
            Self::_ClientPublished => &palette.common.rgb.LIGHT_GRAY,
            Self::Undefined => &palette.common.rgb.DARK_GRAY,
        }
    }

    #[cfg(feature = "gui")]
    pub fn color32(&self, palette: &Palette) -> Color32 {
        let color = self.color_rgb(palette);
        Color32::from_rgb(color.r, color.g, color.b)
    }
}

/// Maps values from our structure to that of existing database.
/// LEGACY DESIGN: DO NOT change `String` return values.
impl From<&AssetStatus> for String {
    fn from(status: &AssetStatus) -> Self {
        let status = match status {
            AssetStatus::NotStarted => "_NOT_START",
            AssetStatus::NoBrief => "_NO_BRIEF",
            AssetStatus::Blocking => "_BLOCKING",
            AssetStatus::Model => "_MODEL",
            AssetStatus::Uv => "_UV",
            AssetStatus::Texture => "_TEXTURE",
            AssetStatus::Lod => "_LOD",
            AssetStatus::Rig => "_RIG",
            AssetStatus::AdFeedback => "_AD_FEEDBACK",
            AssetStatus::FeedbackAddressed => "_FEEDBACK_COMPLETE",
            AssetStatus::SubmitForReview => "_SUBMIT_FOR_REVIEW",
            AssetStatus::QcApproved => "_QC_APPROVED",
            AssetStatus::AdApproved => "_AD_APPROVED",
            AssetStatus::PendingFeedback => "_PENDING_FEEDBACK",
            AssetStatus::ClientFeedback => "_CLIENT_FEEDBACK",
            AssetStatus::ClientApproved => "_CLIENT_APPROVED",
            AssetStatus::_Omitted => "_OMITTED",
            AssetStatus::_OnHold => "_ON_HOLD",
            AssetStatus::_ForReview => "_FOR_REVIEW",
            AssetStatus::_TempPublished => "_TEMP_PUBLISHED",
            AssetStatus::_AnimPublished => "_ANIM_PUBLISHED",
            AssetStatus::_RenderPublished => "_RENDER_PUBLISHED",
            AssetStatus::_ClientPublished => "_CLIENT_PUBLISHED",
            AssetStatus::Undefined => "",
        };
        status.to_string()
    }
}

/// Maps values from existing database to our structure.
impl From<&str> for AssetStatus {
    fn from(status: &str) -> Self {
        match status {
            "_NOT_START" => Self::NotStarted,
            "_NO_BRIEF" => Self::NoBrief,
            "_BLOCKING" => Self::Blocking,
            "_MODEL" => Self::Model,
            "_UV" => Self::Uv,
            "_TEXTURE" => Self::Texture,
            "_LOD" => Self::Lod,
            "_RIG" => Self::Rig,
            "_AD_FEEDBACK" => Self::AdFeedback,
            "_FEEDBACK_COMPLETE" => Self::FeedbackAddressed,
            "_SUBMIT_FOR_REVIEW" => Self::SubmitForReview,
            "_QC_APPROVED" => Self::QcApproved,
            "_AD_APPROVED" => Self::AdApproved,
            "_PENDING_FEEDBACK" => Self::PendingFeedback,
            "_CLIENT_FEEDBACK" => Self::ClientFeedback,
            "_CLIENT_APPROVED" => Self::ClientApproved,
            "_OMITTED" => Self::_Omitted,
            "_ON_HOLD" => Self::_OnHold,
            "_FOR_REVIEW" => Self::_ForReview,
            "_TEMP_PUBLISHED" => Self::_TempPublished,
            "_ANIM_PUBLISHED" => Self::_AnimPublished,
            "_RENDER_PUBLISHED" => Self::_RenderPublished,
            "_CLIENT_PUBLISHED" => Self::_ClientPublished,
            _ => Self::Undefined,
        }
    }
}