thesa 4.3.0

use clap::ValueEnum;
use siteforge::ArchiveOutputProfile;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum TuiScreen {
    Mode,
    Provider,
    Target,
    SiteOptions,
    HfToken,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum Mode {
    Repos,
    Models,
    Datasets,
    Sites,
    Assets,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum RepositoryProvider {
    #[value(alias = "gh")]
    Github,
    #[value(alias = "bb")]
    Bitbucket,
}

impl RepositoryProvider {
    pub(crate) fn label(self) -> &'static str {
        match self {
            Self::Github => "GitHub",
            Self::Bitbucket => "Bitbucket",
        }
    }

    pub(crate) fn manifest_platform(self) -> &'static str {
        match self {
            Self::Github => "github",
            Self::Bitbucket => "bitbucket",
        }
    }
}

impl std::fmt::Display for RepositoryProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.manifest_platform())
    }
}

impl std::fmt::Display for Mode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Mode::Repos => write!(f, "repos"),
            Mode::Models => write!(f, "models"),
            Mode::Datasets => write!(f, "datasets"),
            Mode::Sites => write!(f, "sites"),
            Mode::Assets => write!(f, "assets"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum DatasetProvider {
    Hf,
    Zenodo,
}

impl DatasetProvider {
    pub(crate) fn label(self) -> &'static str {
        match self {
            DatasetProvider::Hf => "Hugging Face Datasets",
            DatasetProvider::Zenodo => "Zenodo",
        }
    }

    pub(crate) fn short_label(self) -> &'static str {
        match self {
            DatasetProvider::Hf => "HF",
            DatasetProvider::Zenodo => "ZEN",
        }
    }
}

impl std::fmt::Display for DatasetProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DatasetProvider::Hf => write!(f, "hf"),
            DatasetProvider::Zenodo => write!(f, "zenodo"),
        }
    }
}

impl From<DatasetProvider> for baseforge::DatasetProvider {
    fn from(value: DatasetProvider) -> Self {
        match value {
            DatasetProvider::Hf => Self::Hf,
            DatasetProvider::Zenodo => Self::Zenodo,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum AssetProvider {
    #[value(alias = "ph")]
    Polyhaven,
}

impl AssetProvider {
    pub(crate) fn label(self) -> &'static str {
        match self {
            Self::Polyhaven => "Poly Haven",
        }
    }

    pub(crate) fn short_label(self) -> &'static str {
        match self {
            Self::Polyhaven => "PH",
        }
    }
}

impl std::fmt::Display for AssetProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Polyhaven => write!(f, "polyhaven"),
        }
    }
}

impl From<AssetProvider> for assetforge::AssetProvider {
    fn from(value: AssetProvider) -> Self {
        match value {
            AssetProvider::Polyhaven => Self::PolyHaven,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum AssetFormat {
    Gltf,
    Fbx,
    Blend,
    Usd,
}

impl std::fmt::Display for AssetFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Gltf => write!(f, "gltf"),
            Self::Fbx => write!(f, "fbx"),
            Self::Blend => write!(f, "blend"),
            Self::Usd => write!(f, "usd"),
        }
    }
}

impl From<AssetFormat> for assetforge::AssetFormat {
    fn from(value: AssetFormat) -> Self {
        match value {
            AssetFormat::Gltf => Self::Gltf,
            AssetFormat::Fbx => Self::Fbx,
            AssetFormat::Blend => Self::Blend,
            AssetFormat::Usd => Self::Usd,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum AssetResolution {
    #[value(name = "1k", alias = "1024")]
    OneK,
    #[value(name = "2k", alias = "2048")]
    TwoK,
    #[value(name = "4k", alias = "4096")]
    FourK,
    #[value(name = "8k", alias = "8192")]
    EightK,
}

impl std::fmt::Display for AssetResolution {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::OneK => write!(f, "1k"),
            Self::TwoK => write!(f, "2k"),
            Self::FourK => write!(f, "4k"),
            Self::EightK => write!(f, "8k"),
        }
    }
}

impl From<AssetResolution> for assetforge::AssetResolution {
    fn from(value: AssetResolution) -> Self {
        match value {
            AssetResolution::OneK => Self::OneK,
            AssetResolution::TwoK => Self::TwoK,
            AssetResolution::FourK => Self::FourK,
            AssetResolution::EightK => Self::EightK,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct SiteTuiOptions {
    pub(crate) full_site: bool,
    pub(crate) max_depth: usize,
    pub(crate) max_pages: usize,
    pub(crate) archive_profile: ArchiveOutputProfile,
    pub(crate) render_js: bool,
    pub(crate) render_js_auto: bool,
}

impl Default for SiteTuiOptions {
    fn default() -> Self {
        Self {
            full_site: true,
            max_depth: 2,
            max_pages: 100,
            archive_profile: ArchiveOutputProfile::Agent,
            render_js: false,
            render_js_auto: false,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum SiteArchiveProfile {
    Full,
    Agent,
    Lean,
}

impl SiteArchiveProfile {
    pub(crate) fn as_output_profile(self) -> ArchiveOutputProfile {
        match self {
            Self::Full => ArchiveOutputProfile::Full,
            Self::Agent => ArchiveOutputProfile::Agent,
            Self::Lean => ArchiveOutputProfile::Lean,
        }
    }
}

impl From<ArchiveOutputProfile> for SiteArchiveProfile {
    fn from(value: ArchiveOutputProfile) -> Self {
        match value {
            ArchiveOutputProfile::Full => Self::Full,
            ArchiveOutputProfile::Agent => Self::Agent,
            ArchiveOutputProfile::Lean => Self::Lean,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum ModelProvider {
    Hf,
    Ollama,
    Civitai,
}

impl ModelProvider {
    pub(crate) fn label(self) -> &'static str {
        match self {
            ModelProvider::Hf => "Hugging Face",
            ModelProvider::Ollama => "Ollama",
            ModelProvider::Civitai => "CivitAI",
        }
    }

    pub(crate) fn short_label(self) -> &'static str {
        match self {
            ModelProvider::Hf => "HF",
            ModelProvider::Ollama => "OLM",
            ModelProvider::Civitai => "CIV",
        }
    }
}

impl std::fmt::Display for ModelProvider {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ModelProvider::Hf => write!(f, "hf"),
            ModelProvider::Ollama => write!(f, "ollama"),
            ModelProvider::Civitai => write!(f, "civitai"),
        }
    }
}

impl From<ModelProvider> for modelforge::ModelProvider {
    fn from(value: ModelProvider) -> Self {
        match value {
            ModelProvider::Hf => Self::Hf,
            ModelProvider::Ollama => Self::Ollama,
            ModelProvider::Civitai => Self::Civitai,
        }
    }
}