use crate::{Theme, ThemeRegistry};
use anyhow::Result;
use gpui::{font_cache::FamilyId, fonts, AppContext};
use schemars::{
    gen::SchemaGenerator,
    schema::{InstanceType, Schema, SchemaObject},
    JsonSchema,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use settings::SettingsJsonSchemaParams;
use std::sync::Arc;
use util::ResultExt as _;

const MIN_FONT_SIZE: f32 = 6.0;
const MIN_LINE_HEIGHT: f32 = 1.0;

#[derive(Clone, JsonSchema)]
pub struct ThemeSettings {
    pub buffer_font_family_name: String,
    pub buffer_font_features: fonts::Features,
    pub buffer_font_family: FamilyId,
    pub(crate) buffer_font_size: f32,
    pub(crate) buffer_line_height: BufferLineHeight,
    #[serde(skip)]
    pub theme: Arc<Theme>,
}

pub struct AdjustedBufferFontSize(pub f32);

#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
pub struct ThemeSettingsContent {
    #[serde(default)]
    pub buffer_font_family: Option<String>,
    #[serde(default)]
    pub buffer_font_size: Option<f32>,
    #[serde(default)]
    pub buffer_line_height: Option<BufferLineHeight>,
    #[serde(default)]
    pub buffer_font_features: Option<fonts::Features>,
    #[serde(default)]
    pub theme: Option<String>,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
pub enum BufferLineHeight {
    #[default]
    Comfortable,
    Standard,
    Custom(f32),
}

impl BufferLineHeight {
    pub fn value(&self) -> f32 {
        match self {
            BufferLineHeight::Comfortable => 1.618,
            BufferLineHeight::Standard => 1.3,
            BufferLineHeight::Custom(line_height) => *line_height,
        }
    }
}

impl ThemeSettings {
    pub fn buffer_font_size(&self, cx: &AppContext) -> f32 {
        if cx.has_global::<AdjustedBufferFontSize>() {
            cx.global::<AdjustedBufferFontSize>().0
        } else {
            self.buffer_font_size
        }
        .max(MIN_FONT_SIZE)
    }

    pub fn line_height(&self) -> f32 {
        f32::max(self.buffer_line_height.value(), MIN_LINE_HEIGHT)
    }
}

pub fn adjusted_font_size(size: f32, cx: &AppContext) -> f32 {
    if cx.has_global::<AdjustedBufferFontSize>() {
        let buffer_font_size = settings::get::<ThemeSettings>(cx).buffer_font_size;
        let delta = cx.global::<AdjustedBufferFontSize>().0 - buffer_font_size;
        size + delta
    } else {
        size
    }
    .max(MIN_FONT_SIZE)
}

pub fn adjust_font_size(cx: &mut AppContext, f: fn(&mut f32)) {
    if !cx.has_global::<AdjustedBufferFontSize>() {
        let buffer_font_size = settings::get::<ThemeSettings>(cx).buffer_font_size;
        cx.set_global(AdjustedBufferFontSize(buffer_font_size));
    }

    cx.update_global::<AdjustedBufferFontSize, _, _>(|delta, cx| {
        f(&mut delta.0);
        delta.0 = delta
            .0
            .max(MIN_FONT_SIZE - settings::get::<ThemeSettings>(cx).buffer_font_size);
    });
    cx.refresh_windows();
}

pub fn reset_font_size(cx: &mut AppContext) {
    if cx.has_global::<AdjustedBufferFontSize>() {
        cx.remove_global::<AdjustedBufferFontSize>();
        cx.refresh_windows();
    }
}

impl settings::Setting for ThemeSettings {
    const KEY: Option<&'static str> = None;

    type FileContent = ThemeSettingsContent;

    fn load(
        defaults: &Self::FileContent,
        user_values: &[&Self::FileContent],
        cx: &AppContext,
    ) -> Result<Self> {
        let buffer_font_features = defaults.buffer_font_features.clone().unwrap();
        let themes = cx.global::<Arc<ThemeRegistry>>();

        let mut this = Self {
            buffer_font_family: cx
                .font_cache()
                .load_family(
                    &[defaults.buffer_font_family.as_ref().unwrap()],
                    &buffer_font_features,
                )
                .unwrap(),
            buffer_font_family_name: defaults.buffer_font_family.clone().unwrap(),
            buffer_font_features,
            buffer_font_size: defaults.buffer_font_size.unwrap(),
            buffer_line_height: defaults.buffer_line_height.unwrap(),
            theme: themes.get(defaults.theme.as_ref().unwrap()).unwrap(),
        };

        for value in user_values.into_iter().copied().cloned() {
            let font_cache = cx.font_cache();
            let mut family_changed = false;
            if let Some(value) = value.buffer_font_family {
                this.buffer_font_family_name = value;
                family_changed = true;
            }
            if let Some(value) = value.buffer_font_features {
                this.buffer_font_features = value;
                family_changed = true;
            }
            if family_changed {
                if let Some(id) = font_cache
                    .load_family(&[&this.buffer_font_family_name], &this.buffer_font_features)
                    .log_err()
                {
                    this.buffer_font_family = id;
                }
            }

            if let Some(value) = &value.theme {
                if let Some(theme) = themes.get(value).log_err() {
                    this.theme = theme;
                }
            }

            merge(&mut this.buffer_font_size, value.buffer_font_size);
            merge(&mut this.buffer_line_height, value.buffer_line_height);
        }

        Ok(this)
    }

    fn json_schema(
        generator: &mut SchemaGenerator,
        params: &SettingsJsonSchemaParams,
        cx: &AppContext,
    ) -> schemars::schema::RootSchema {
        let mut root_schema = generator.root_schema_for::<ThemeSettingsContent>();
        let theme_names = cx
            .global::<Arc<ThemeRegistry>>()
            .list_names(params.staff_mode)
            .map(|theme_name| Value::String(theme_name.to_string()))
            .collect();

        let theme_name_schema = SchemaObject {
            instance_type: Some(InstanceType::String.into()),
            enum_values: Some(theme_names),
            ..Default::default()
        };

        root_schema
            .definitions
            .extend([("ThemeName".into(), theme_name_schema.into())]);

        root_schema
            .schema
            .object
            .as_mut()
            .unwrap()
            .properties
            .extend([(
                "theme".to_owned(),
                Schema::new_ref("#/definitions/ThemeName".into()),
            )]);

        root_schema
    }
}

fn merge<T: Copy>(target: &mut T, value: Option<T>) {
    if let Some(value) = value {
        *target = value;
    }
}