thesa 4.1.43

use clap::ValueEnum;

#[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,
}

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"),
        }
    }
}

#[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)]
pub(crate) struct SiteTuiOptions {
    pub(crate) full_site: bool,
    pub(crate) max_depth: usize,
    pub(crate) max_pages: usize,
    pub(crate) archive_profile: SiteArchiveProfile,
    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: SiteArchiveProfile::Full,
            render_js: false,
            render_js_auto: false,
        }
    }
}

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

#[cfg(not(windows))]
impl From<SiteArchiveProfile> for siteforge::ArchiveOutputProfile {
    fn from(value: SiteArchiveProfile) -> Self {
        match value {
            SiteArchiveProfile::Full => Self::Full,
            SiteArchiveProfile::Agent => Self::Agent,
            SiteArchiveProfile::Lean => Self::Lean,
        }
    }
}

#[cfg(not(windows))]
impl From<siteforge::ArchiveOutputProfile> for SiteArchiveProfile {
    fn from(value: siteforge::ArchiveOutputProfile) -> Self {
        match value {
            siteforge::ArchiveOutputProfile::Full => Self::Full,
            siteforge::ArchiveOutputProfile::Agent => Self::Agent,
            siteforge::ArchiveOutputProfile::Lean => Self::Lean,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
pub(crate) enum SiteforgeExportFormat {
    Markdown,
    BasicMarkdown,
    Jsonl,
    Json,
    Html,
    Warc,
    Zip,
    Tar,
    AgentTar,
    All,
}

impl SiteforgeExportFormat {
    pub(crate) fn as_str(self) -> &'static str {
        match self {
            Self::Markdown => "markdown",
            Self::BasicMarkdown => "basic-markdown",
            Self::Jsonl => "jsonl",
            Self::Json => "json",
            Self::Html => "html",
            Self::Warc => "warc",
            Self::Zip => "zip",
            Self::Tar => "tar",
            Self::AgentTar => "agent-tar",
            Self::All => "all",
        }
    }
}

#[cfg(not(windows))]
impl From<SiteforgeExportFormat> for siteforge::ExportFormat {
    fn from(value: SiteforgeExportFormat) -> Self {
        match value {
            SiteforgeExportFormat::Markdown => Self::Markdown,
            SiteforgeExportFormat::BasicMarkdown => Self::BasicMarkdown,
            SiteforgeExportFormat::Jsonl => Self::Jsonl,
            SiteforgeExportFormat::Json => Self::Json,
            SiteforgeExportFormat::Html => Self::Html,
            SiteforgeExportFormat::Warc => Self::Warc,
            SiteforgeExportFormat::Zip => Self::Zip,
            SiteforgeExportFormat::Tar => Self::Tar,
            SiteforgeExportFormat::AgentTar => Self::AgentTar,
            SiteforgeExportFormat::All => Self::All,
        }
    }
}

#[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,
        }
    }
}