// SPDX-License-Identifier: GPL-3.0-only

use cosmic::Element;

use cosmic::iced::widget::{column, row};

use cosmic::iced::{Alignment, Length};

use cosmic::widget::{self, settings, text};

use crate::core::app::AppModel;

use crate::daemon::backends::{BackendInfo, BackendOption, BackendSecret};

use crate::daemon::client::ContextMode;

use crate::ui::messages::{BackendMessage, ContextsMessage, Message};

use super_stt_shared::models::contexts::DictationContext;

use super::surface::muted_text_color;

/// Body of the per-backend configuration sheet (shown in the right-side

/// context drawer): the backend's secrets (system keyring) and options (daemon

/// config) as one settings section. The drawer supplies the title and close

/// affordance, so there's no in-body header or Back button.

pub fn configure_sheet<'a>(backend: &'a BackendInfo, app: &'a AppModel) -> Element<'a, Message> {

    let spacing = cosmic::theme::spacing();

    let mut body: Vec<Element<'a, Message>> = Vec::new();

    // Surface a failed secret/option save inline in the sheet (Tier 1 #15)

    // instead of dropping it to the log.

    if let Some(message) = app.action_error_for(crate::state::ErrorScope::ConfigureBackend) {

        body.push(crate::ui::views::common::error_banner(message));

    }

    // The dictation context comes first: it is the one setting here that is

    // not the backend's own, and the one most likely to be changed twice in a

    // sitting. Only for a backend that declared it can use one — on any other,

    // the row would offer a choice with no effect.

    if backend.accepts_context {

        body.push(context_row(backend, app));

    }

    if backend.secrets.is_empty() && backend.options.is_empty() {

        body.push(

            text::body(if backend.accepts_context {

                "This backend has no other settings."

            } else {

                "This backend has nothing to configure."

            })

            .into(),

        );

    } else {

        let mut section = settings::section();

        for secret in &backend.secrets {

            let key = (backend.source.clone(), secret.name.clone());

            let configured = app

                .backend_secret_configured

                .get(&key)

                .copied()

                .unwrap_or(false);

            let input = app

                .backend_secret_inputs

                .get(&key)

                .map_or("", String::as_str);

            section = section.add(secret_row(&backend.source, secret, configured, input));

        }

        for option in &backend.options {

            // A boolean has exactly two values and no way to be typed wrong,

            // so it gets a switch that writes on the press. Everything else is

            // free text and keeps its field + Save.

            if option.is_bool() {

                section = section.add(bool_option_row(&backend.source, option));

                continue;

            }

            // An option offering a closed set is the same case as the switch,

            // widened: nothing to type, so nothing to type wrong, and picking

            // is the write. It is what an option whose allowed values lived in

            // its help text always wanted to be.

            if option.has_choices() {

                section = section.add(choice_option_row(&backend.source, option));

                continue;

            }

            let key = (backend.source.clone(), option.name.clone());

            let input = app

                .backend_option_inputs

                .get(&key)

                .map_or("", String::as_str);

            section = section.add(option_row(&backend.source, option, input));

        }

        body.push(section.into());

    }

    column(body)

        .spacing(spacing.space_m)

        .width(Length::Fill)

        .into()

}

/// Which dictation context this backend uses: the active one, a specific one,

/// or none.

///

/// A dropdown rather than the three buttons the API has, because the three

/// states are mutually exclusive and one line of a settings sheet is not the

/// place for a row of verbs. "Follow the active context" is first and is the

/// default; "No context" is last, because it is the one a user picks

/// deliberately and rarely.

fn context_row<'a>(backend: &'a BackendInfo, app: &'a AppModel) -> Element<'a, Message> {

    let spacing = cosmic::theme::spacing();

    let source = backend.source.clone();

    let state = app.contexts.backend_contexts.get(&backend.source);

    // Index 0 is "follow", index 1 is "none", and the rest are the contexts in

    // the order the page lists them — so an index maps back to a choice without

    // a second lookup.

    let contexts = app.contexts.choices();

    let mut labels: Vec<String> = Vec::with_capacity(contexts.len() + 2);

    labels.push(match app.contexts.active.as_deref() {

        Some(id) => format!(

            "Follow the active context ({})",

            app.contexts

                .get(id)

                .map_or_else(|| id.to_string(), DictationContext::display_name)

        ),

        None => "Follow the active context (none right now)".to_string(),

    });

    labels.push("No context".to_string());

    labels.extend(contexts.iter().map(|(_, name)| name.clone()));

    let selected = match state.map(|s| s.mode) {

        None | Some(ContextMode::Active) => Some(0),

        Some(ContextMode::Nothing) => Some(1),

        Some(ContextMode::Pinned) => state

            .and_then(|s| s.id.as_deref())

            .and_then(|id| contexts.iter().position(|(cid, _)| cid == id))

            .map(|i| i + 2)

            // Pinned to a context that has since been deleted. The daemon keeps

            // the pin, so this reads back as pinned with an id nothing matches;

            // showing "follow" would be a lie about what the backend receives.

            .or(Some(1)),

    };

    let ids: Vec<String> = contexts.into_iter().map(|(id, _)| id).collect();

    let dropdown = widget::dropdown(labels, selected, move |index| match index {

        0 => Message::Contexts(ContextsMessage::BackendFollowsActive(source.clone())),

        1 => Message::Contexts(ContextsMessage::BackendPinned {

            source: source.clone(),

            id: None,

        }),

        n => Message::Contexts(ContextsMessage::BackendPinned {

            source: source.clone(),

            id: ids.get(n - 2).cloned(),

        }),

    });

    let hint = state.and_then(|s| s.context.as_ref()).map_or_else(

        || "Nothing is sent to this backend right now.".to_string(),

        |context| format!("Sending {}.", context.display_name()),

    );

    widget::column::with_capacity(2)

        .spacing(spacing.space_xxs)

        .push(config_label(

            "Dictation context".to_string(),

            Some(hint),

            false,

        ))

        .push(dropdown)

        .into()

}

/// A label + optional caption stacked vertically, used as the heading above a

/// configuration row's control. The caption is dimmed so it reads as a hint.

/// When `required` is true, an accent-colored asterisk follows the title to

/// signal that the field must be filled.

pub(super) fn config_label<'a>(

    title: String,

    hint: Option<String>,

    required: bool,

) -> Element<'a, Message> {

    let mut block = widget::column::with_capacity(2).spacing(cosmic::theme::spacing().space_xxxs);

    let title_row: Element<'a, Message> = if required {

        row![

            text::body(title),

            text::body(" *").class(cosmic::theme::Text::Accent),

        ]

        .into()

    } else {

        text::body(title).into()

    };

    block = block.push(title_row);

    if let Some(hint) = hint.filter(|h| !h.is_empty()) {

        block =

            block.push(text::caption(hint).class(cosmic::theme::Text::Color(muted_text_color())));

    }

    block.into()

}

/// One secret-entry row for a backend (e.g. an API key): the label/description

/// over a full-width password field + Save when unconfigured, or a "Configured"

/// badge + Remove when stored. The control gets its own row beneath the label

/// so the input spans the (narrow) sheet width instead of being squeezed to the

/// right of the label.

pub(super) fn secret_row<'a>(

    source: &'a str,

    secret: &'a BackendSecret,

    configured: bool,

    input: &'a str,

) -> Element<'a, Message> {

    let spacing = cosmic::theme::spacing();

    // Show the backend's human label when set; fall back to the technical name.

    let display = secret.label.clone().unwrap_or_else(|| secret.name.clone());

    let description = (!secret.description.is_empty()).then(|| secret.description.clone());

    let label = config_label(display, description, secret.required);

    let source_owned = source.to_string();

    let name_owned = secret.name.clone();

    let control: Element<'a, Message> = if configured {

        let remove_source = source_owned.clone();

        let remove_name = name_owned.clone();

        row![

            text::body("Configured").width(Length::Fill),

            widget::button::destructive("Remove").on_press(Message::Backend(

                BackendMessage::BackendSecretRemoved {

                    source: remove_source,

                    name: remove_name,

                },

            )),

        ]

        .spacing(spacing.space_s)

        .align_y(Alignment::Center)

        .into()

    } else {

        let input_source = source_owned.clone();

        let input_name = name_owned.clone();

        let field = widget::text_input("Enter API key...", input)

            .on_input(move |value| {

                Message::Backend(BackendMessage::BackendSecretInputChanged {

                    source: input_source.clone(),

                    name: input_name.clone(),

                    value,

                })

            })

            .password()

            .width(Length::Fill);

        let save = widget::button::standard("Save").on_press(Message::Backend(

            BackendMessage::BackendSecretSaved {

                source: source_owned,

                name: name_owned,

            },

        ));

        row![field, save]

            .spacing(spacing.space_xs)

            .align_y(Alignment::Center)

            .into()

    };

    settings::item_row(vec![

        column![label, control]

            .spacing(spacing.space_xs)

            .width(Length::Fill)

            .into(),

    ])

    .into()

}

/// One `type = "bool"` option as a settings row with a switch: label,

/// description, and the toggle opposite them.

///

/// No Save and no Reset — the flip is the save, and flipping back to the

/// backend's default is what clearing an override means for two values. The

/// switch shows the current state, so the "(default: …)" suffix the text rows

/// carry would only restate it.

pub(super) fn bool_option_row<'a>(

    source: &'a str,

    option: &'a BackendOption,

) -> Element<'a, Message> {

    let display = option.label.clone().unwrap_or_else(|| option.name.clone());

    let source = source.to_string();

    let name = option.name.clone();

    let toggle = widget::toggler(option.bool_value()).on_toggle(move |value| {

        Message::Backend(BackendMessage::BackendOptionToggled {

            source: source.clone(),

            name: name.clone(),

            value,

        })

    });

    let mut item = settings::item::builder(display);

    if !option.description.is_empty() {

        item = item.description(option.description.clone());

    }

    item.control(toggle).into()

}

/// One option row for an option that declares `choices`: the label and

/// description beside a dropdown of the values the backend accepts.

///

/// Like the switch, and unlike the text field, there is no Save button —

/// picking is the write. And as with the switch, picking the declared default

/// clears the override rather than storing a copy of it, which is what keeps

/// the Reset affordance unnecessary here.

///

/// A stored value the backend no longer offers leaves the dropdown showing its

/// placeholder rather than a wrong selection, so the user picks again.

pub(super) fn choice_option_row<'a>(

    source: &'a str,

    option: &'a BackendOption,

) -> Element<'a, Message> {

    let display = option.label.clone().unwrap_or_else(|| option.name.clone());

    let source = source.to_string();

    let name = option.name.clone();

    let choices = option.choices.clone();

    let dropdown = widget::dropdown(

        option.choices.as_slice(),

        option.choice_index(),

        move |index| {

            Message::Backend(BackendMessage::BackendOptionChosen {

                source: source.clone(),

                name: name.clone(),

                value: choices[index].clone(),

            })

        },

    )

    .placeholder("Select");

    let mut item = settings::item::builder(display);

    if !option.description.is_empty() {

        item = item.description(option.description.clone());

    }

    item.control(dropdown).into()

}

/// One option-entry row for a backend (e.g. `base_url`): the label/description

/// over a full-width text field + Save on its own row beneath, so the input

/// isn't squeezed to the right of the label in the narrow sheet.

/// When an override is active (stored value differs from the default), a Reset

/// button is shown alongside Save to clear the override and revert to the

/// daemon default.

pub(super) fn option_row<'a>(

    source: &'a str,

    option: &'a BackendOption,

    input: &'a str,

) -> Element<'a, Message> {

    let spacing = cosmic::theme::spacing();

    let display = option.label.clone().unwrap_or_else(|| option.name.clone());

    let mut hint = option.description.clone();

    if let Some(default) = &option.default

        && !default.is_empty()

    {

        if hint.is_empty() {

            hint = format!("Default: {default}");

        } else {

            hint = format!("{hint} (default: {default})");

        }

    }

    let label = config_label(display, (!hint.is_empty()).then_some(hint), option.required);

    let input_source = source.to_string();

    let input_name = option.name.clone();

    let save_source = input_source.clone();

    let save_name = input_name.clone();

    let field = widget::text_input("", input)

        .on_input(move |value| {

            Message::Backend(BackendMessage::BackendOptionInputChanged {

                source: input_source.clone(),

                name: input_name.clone(),

                value,

            })

        })

        .width(Length::Fill);

    let save = widget::button::standard("Save").on_press(Message::Backend(

        BackendMessage::BackendOptionSaved {

            source: save_source,

            name: save_name,

        },

    ));

    // Show Reset only when an override is stored (value differs from default).

    let has_override = option.value.as_deref() != option.default.as_deref();

    let control: Element<'a, Message> = if has_override {

        let reset_source = source.to_string();

        let reset_name = option.name.clone();

        let reset = widget::button::standard("Reset").on_press(Message::Backend(

            BackendMessage::BackendOptionReset {

                source: reset_source,

                name: reset_name,

            },

        ));

        row![field, save, reset]

            .spacing(spacing.space_xs)

            .align_y(Alignment::Center)

            .into()

    } else {

        row![field, save]

            .spacing(spacing.space_xs)

            .align_y(Alignment::Center)

            .into()

    };

    settings::item_row(vec![

        column![label, control]

            .spacing(spacing.space_xs)

            .width(Length::Fill)

            .into(),

    ])

    .into()

}