use anyhow::{Context, anyhow};
use db::kvp::KeyValueStore;
use gpui::App;
use ui::Window;

use crate::preview;
use crate::shape::{self, Centered, RelativeHeight, RelativeWidth, Shape, ViewportFraction};

const PICKERS_NAMESPACE: &str = "pickers_v2";

pub(crate) fn store_shape_for_this_layout(
    picker_delegate: &'static str,
    preview_layout: Option<preview::Layout>,
    shape: shape::Centered,
    window: &ui::Window,
    cx: &App,
) {
    let shape = PickerConfig::from_centered(shape, window);

    let kvp = KeyValueStore::global(cx);
    db::write_and_log(cx, async move || {
        kvp.scoped(PICKERS_NAMESPACE)
            .write(
                shape_key(picker_delegate, preview_layout),
                serde_json::to_string(&shape).context("Could not serialize size of picker")?,
            )
            .await?;
        // Must be written after the shape or loading can break
        // if this future is ever cancelled.
        kvp.scoped(PICKERS_NAMESPACE)
            .write(
                last_layout_key(picker_delegate),
                layout_as_str(preview_layout).to_string(),
            )
            .await
    });
}

/// Persist the last-used preview layout without touching the stored shape.
///
/// Changing the preview position (e.g. right/below/hidden) without resizing
/// must still be remembered, so this is called whenever the layout changes.
pub(crate) fn store_last_layout(
    picker_delegate: &'static str,
    preview_layout: Option<preview::Layout>,
    cx: &App,
) {
    let kvp = KeyValueStore::global(cx);
    db::write_and_log(cx, async move || {
        kvp.scoped(PICKERS_NAMESPACE)
            .write(
                last_layout_key(picker_delegate),
                layout_as_str(preview_layout).to_string(),
            )
            .await
    });
}

pub(crate) fn try_load_shape(
    picker_delegate: &'static str,
    preview_layout: impl Into<Option<preview::Layout>>,
    cx: &App,
) -> anyhow::Result<Option<Shape>> {
    let Some(shape) = KeyValueStore::global(cx)
        .scoped(PICKERS_NAMESPACE)
        .read(&shape_key(picker_delegate, preview_layout.into()))
        .context("Could not read picker shape from KeyValueStore")?
    else {
        return Ok(None);
    };

    let shape = serde_json::from_str::<PickerConfig>(&shape)
        .context("Could not deserialize loaded picker shape from persistence")?
        .into_centered();
    Ok(Some(Shape::HorizontallyCentered(shape)))
}

pub(crate) fn load_last_preview_layout(
    picker_delegate: &'static str,
    cx: &App,
) -> anyhow::Result<Option<preview::Layout>> {
    let Some(last_layout) = KeyValueStore::global(cx)
        .scoped(PICKERS_NAMESPACE)
        .read(&last_layout_key(picker_delegate))
        .context("Could not read last picker layout from KeyValueStore")?
    else {
        return Ok(None);
    };

    parse_layout(&last_layout)
}

fn shape_key(picker_delegate: &'static str, preview_layout: Option<preview::Layout>) -> String {
    format!("{picker_delegate}/{}", layout_as_str(preview_layout))
}

fn last_layout_key(picker_delegate: &'static str) -> String {
    format!("{picker_delegate}/LAST_PREVIEW_LAYOUT")
}

fn layout_as_str(layout: Option<preview::Layout>) -> &'static str {
    match layout {
        Some(preview::Layout::Hidden) => "hidden",
        Some(preview::Layout::Below) => "below",
        Some(preview::Layout::Right) => "right",
        None => "none",
    }
}

fn parse_layout(s: &str) -> anyhow::Result<Option<preview::Layout>> {
    Ok(Some(match s {
        "hidden" => preview::Layout::Hidden,
        "below" => preview::Layout::Below,
        "right" => preview::Layout::Right,
        "none" => return Ok(None),
        _ => return Err(anyhow!("Unknown layout: `{}`", s)),
    }))
}

/// A resized picker for persisting its size. All values are stored as fractions
/// of the viewport so they remain meaningful across window sizes.
#[derive(Clone, Copy, serde::Serialize, serde::Deserialize)]
pub(crate) struct PickerConfig {
    width: f32,        // relative fraction of viewport
    height: f32,       // relative fraction of viewport
    preview_size: f32, // relative fraction of viewport
}

impl PickerConfig {
    pub(crate) fn from_centered(shape: Centered, window: &Window) -> Self {
        PickerConfig {
            width: shape.width.as_viewport_fraction(window).raw(),
            height: shape.height.as_viewport_fraction(window).raw(),
            preview_size: shape.preview_size.raw(),
        }
    }

    pub(crate) fn into_centered(self) -> Centered {
        Centered {
            width: RelativeWidth::viewport(self.width.clamp(0.0, 1.0)),
            height: RelativeHeight::viewport(self.height.clamp(0.0, 1.0)),
            preview_size: ViewportFraction::fraction(self.preview_size.clamp(0.0, 1.0)),
        }
    }
}