use std::path::Path;
use std::sync::LazyLock;

use crate::asset::{Assets, Label as AssetLabel, Submitter as AssetSubmitter};
use crate::builder;
use crate::color::Color;
use crate::data_types::dimens::Dimens;
use crate::image::{Error as ImageError, Image};

pub static WHITE_1X1_ASSET_LABEL: LazyLock<AssetLabel> = LazyLock::new(|| AssetLabel {
    path: Path::new("").into(),
    name: Some("white_1x1_texture".into()),
});

#[derive(Debug, Clone)]
pub struct Texture
{
    pub image: Image,
    pub properties: Properties,
}

builder! {
/// Texture properties
#[builder(name = PropertiesBuilder, derives=(Debug, Clone))]
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct Properties
{
    pub wrap: Wrapping,
    pub magnifying_filter: Filtering,
    pub minifying_filter: Filtering,
}
}

impl Properties
{
    pub fn builder() -> PropertiesBuilder
    {
        PropertiesBuilder::default()
    }
}

impl Default for Properties
{
    fn default() -> Self
    {
        Self {
            wrap: Wrapping::Repeat,
            magnifying_filter: Filtering::Linear,
            minifying_filter: Filtering::Nearest,
        }
    }
}

impl Default for PropertiesBuilder
{
    fn default() -> Self
    {
        Properties::default().into()
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum Filtering
{
    Nearest,
    Linear,
}

/// Texture wrapping.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum Wrapping
{
    Repeat,
    MirroredRepeat,
    ClampToEdge,
    ClampToBorder,
}

builder! {
#[builder(name = ImportSettingsBuilder, derives=(Debug, Clone))]
#[derive(Debug, Default, Clone)]
#[non_exhaustive]
pub struct ImportSettings {
    properties: Properties,
}
}

impl ImportSettings
{
    pub fn builder() -> ImportSettingsBuilder
    {
        ImportSettingsBuilder::default()
    }
}

impl Default for ImportSettingsBuilder
{
    fn default() -> Self
    {
        ImportSettings::default().into()
    }
}

pub(crate) fn initialize(assets: &mut Assets)
{
    assets.set_importer::<_, _>(["png", "jpg"], import);

    assets.store_with_label(
        WHITE_1X1_ASSET_LABEL.clone(),
        Texture {
            image: Image::from_color_and_alpha(
                Dimens { width: 1, height: 1 },
                Color::WHITE_U8,
                1,
            ),
            properties: Properties::default(),
        },
    );
}

fn import(
    asset_submitter: &mut AssetSubmitter<'_>,
    path: &Path,
    settings: Option<&'_ ImportSettings>,
) -> Result<(), ImageError>
{
    asset_submitter.submit_store(Texture {
        image: Image::open(path)?,
        properties: settings
            .map(|settings| settings.properties.clone())
            .unwrap_or_default(),
    });

    Ok(())
}