//! The dashboard settings sub-nav, described.
//!
//! Shape 2, step 4 (`6b24f2df`), and the fourth described strip. Unlike the
//! three before it this one is a strip inside a panel: `user_settings.html` is
//! itself the Settings tab of the user dashboard, whose own strip is step 5.
//!
//! # It did not look like a tab strip, and it is one
//!
//! `<nav class="settings-nav">` of six `<a>` links, not `.tabs[role=tablist]`,
//! which is why a grep for the tablist role never found it. Behaviourally it is
//! the folder semantic exactly: one section showing at a time, the chosen link
//! carrying `is-selected`, each link fetching its section. The four lines of
//! `static/tab-user-settings.js` existed to move that one class, and they are
//! what a described strip does for free.
//!
//! # The reader-visible change, and why it is the ruling working
//!
//! The nav was a column beside the content on a wide viewport
//! (`.settings-layout { display: flex }`) and a wrapped row of links below
//! `--break-*`. Described, it is the renderer's tab strip on every viewport,
//! which is the narrow-viewport look everywhere.
//!
//! That is Max's Shape 2 ruling applied rather than bent: the strip is described
//! and how it is drawn is the renderer's, the same way the overflow menu was.
//! `RegionKind::TabGroup`'s own doc prose says "with tabs above", which reads
//! like a constraint and is not one -- it is a renderer's habit written into a
//! doc comment. Worth correcting there rather than working around here.
//!
//! # Two of the sections are described screens
//!
//! SSH Keys and Forums answer for themselves when `QUASI_SCREENS` names them, so
//! they name the region their answer replaces and this strip must not override
//! it. That is the library strip's branch, back after step 2 and step 3 had none.
//!
//! Both constants said `settings-body`, the single pane the hand-written nav
//! swapped into. There is no single pane now -- each section is its own frame --
//! so both moved to the frame that is theirs, and the frame ids are theirs to
//! keep: `ssh_keys::REGION` and `forum_memberships::SETTINGS_REGION`.
//!
//! # The deep link nests, and this is the second level
//!
//! `3a7de032`. `?tab=settings` opens this strip and `&section=creator` chooses
//! within it, the same `shown_at` / `section_at` / [`FILLABLE`] shape the five
//! tab strips have, one level down. Five sites wanted a section rather than a
//! tab: two "Apply for Creator Access" buttons, the join wizard's "I want to
//! sell", the creators page's "Apply from Dashboard", and "Manage SSH Keys" on
//! the project code tab. The last three spelled it as `/dashboard#tab-plan` or
//! `#tab-ssh-keys`, ids this page has never had, so they did nothing at all.
//!
//! # The seventh section, and why it is here rather than a tab
//!
//! Cloud Sync (`47e67540`). The user-level SyncKit surface has always existed
//! and has never been reachable: the strip above never carried a button for it
//! and the `#tab-synckit` links that meant it named an id this page has never
//! had. It is a section rather than a dashboard tab because account-level
//! integrations live here, and it is gated on owning a sync app because Cloud
//! Sync is for developers shipping their own software and would otherwise be an
//! empty section on every account.
//!
//! # What this retires
//!
//! `static/tab-user-settings.js` entirely, its `<script>` tag, the
//! `window.setSettingsSectionBtn` wrapper in `actions-tabs.js`, and the six
//! `data-action` sites. The first whole file Shape 2 has deleted.

use makeover_layout as layout;
use quasi_router::{Action, Node, RegionKind, Slot};
use quasi_webview::Webview;

/// The region the whole strip occupies.
///
/// A new id: the pane it replaces was `settings-body`, which was one pane for
/// six sections, and that name now belongs to no single thing. Nothing outside
/// pointed at the layout wrapper, so this is not a rename anything follows.
const STRIP: &str = "settings-sections";

/// What a section is conditional on.
#[derive(PartialEq, Eq)]
enum Gate {
    /// Every reader sees it.
    Always,
    /// Only a reader who can create projects, since only they have media.
    Media,
    /// Only where the server has a git repositories path.
    Git,
    /// Only where the Multithreaded integration is configured.
    Forums,
    /// Only a reader who owns at least one sync app.
    ///
    /// Cloud Sync is for developers shipping their own software, so on nearly
    /// every account this section is absent rather than empty (`47e67540`).
    SyncKit,
}

/// What this reader is entitled to see, gathered once by the caller.
///
/// Four gates were four positional `bool`s until the fifth section arrived, at
/// which point every call site read as a row of anonymous `true`s. Naming them
/// costs one struct and makes a transposed pair impossible.
#[derive(Clone, Copy)]
pub struct Gates {
    /// The reader can create projects, so they have media.
    pub has_media: bool,
    /// The server has a git repositories path.
    pub git_enabled: bool,
    /// The Multithreaded integration is configured.
    pub has_mt_memberships: bool,
    /// The reader owns at least one sync app.
    pub has_sync_apps: bool,
}

/// One section: what it is called, where its frame is, and what serves it.
struct Section {
    label: &'static str,
    /// What a `?section=` names it, which is also the tail of its route.
    name: &'static str,
    gate: Gate,
    /// The id this section's answer lands in. Also the described screen's own
    /// region name, for the two that have one.
    panel: &'static str,
    route: &'static str,
    /// The described screen behind this section, when there is one.
    screen: Option<&'static str>,
}

/// Every section the settings tab can show, in the order the strip draws them.
const SECTIONS: &[Section] = &[
    Section {
        label: "Profile",
        name: "profile",
        gate: Gate::Always,
        panel: "settings-profile",
        route: "/dashboard/tabs/profile",
        screen: None,
    },
    Section {
        label: "Account",
        name: "account",
        gate: Gate::Always,
        panel: "settings-account",
        route: "/dashboard/tabs/account",
        screen: None,
    },
    Section {
        label: "Creator Plan",
        name: "creator",
        gate: Gate::Always,
        panel: "settings-creator",
        route: "/dashboard/tabs/creator",
        screen: None,
    },
    Section {
        label: "Media",
        name: "media",
        gate: Gate::Media,
        panel: "settings-media",
        route: "/dashboard/tabs/media",
        screen: None,
    },
    Section {
        label: "SSH Keys",
        name: "ssh-keys",
        gate: Gate::Git,
        panel: super::ssh_keys::REGION,
        route: super::ssh_keys::PATH,
        screen: Some(super::ssh_keys::SCREEN),
    },
    Section {
        label: "Forums",
        name: "forums",
        gate: Gate::Forums,
        panel: super::forum_memberships::SETTINGS_REGION,
        route: super::forum_memberships::SETTINGS_PATH,
        screen: Some(super::forum_memberships::SETTINGS_SCREEN),
    },
    Section {
        label: "Cloud Sync",
        name: "synckit",
        gate: Gate::SyncKit,
        panel: "settings-synckit",
        route: "/dashboard/tabs/synckit",
        screen: None,
    },
];

/// The sections whose contents the settings builder can render inline.
///
/// The shown section is the one that does not fetch, so a name outside this list
/// would open a blank frame rather than a slow one and answers Profile instead.
/// Profile is here because it is what the tab has always opened on; Creator Plan
/// and SSH Keys because five sites link to one of the two, measured 2026-08-19.
/// Cloud Sync because `synckit_return_url` links to it: a developer coming back
/// from Stripe must land on the app they were just billed for, which is the
/// whole reason the section exists (`47e67540`).
/// Account, Media and Forums are pressed rather than linked to.
const FILLABLE: &[&str] = &["profile", "creator", "ssh-keys", "synckit"];

/// The sections this reader sees, in strip order.
///
/// Never empty: Profile and Account are [`Gate::Always`].
fn visible(gates: Gates) -> Vec<&'static Section> {
    SECTIONS
        .iter()
        .filter(|section| match section.gate {
            Gate::Always => true,
            Gate::Media => gates.has_media,
            Gate::Git => gates.git_enabled,
            Gate::Forums => gates.has_mt_memberships,
            Gate::SyncKit => gates.has_sync_apps,
        })
        .collect()
}

/// Which section a `?section=` asks for, or Profile.
///
/// The second level of the deep link the tab strip reads: `?tab=settings` opens
/// this strip and `&section=creator` chooses within it, so a link that means the
/// Creator Plan lands on it filled rather than on Profile.
///
/// Fillability depends on the switch as well as on the name. A described section
/// answers for itself through `quasi_router`, which the page handler is not in a
/// position to call, so with `QUASI_SCREENS` naming SSH Keys the page cannot fill
/// it: the alternative would be filling the frame with the Askama rendering the
/// switch exists to replace. The link opens Profile there and the section is a
/// press away. Unset, which is every deployment today, it fills.
#[must_use]
pub fn shown_at(asked: Option<&str>, gates: Gates) -> usize {
    let Some(asked) = asked else { return 0 };
    if !FILLABLE.contains(&asked) {
        return 0;
    }
    visible(gates)
        .iter()
        .position(|section| section.name == asked && section.screen.is_none())
        .unwrap_or(0)
}

/// The name of a section by index, so the caller knows which one to render.
#[must_use]
pub fn section_at(shown: usize, gates: Gates) -> &'static str {
    let sections = visible(gates);
    sections
        .get(shown)
        .map_or(sections[0].name, |section| section.name)
}

/// The markup, for `partials/tabs/user_settings.html` to drop in.
///
/// `section` is the shown section's contents, rendered by the caller, exactly as
/// the `{% include %}` did for Profile. The settings tab has never fetched on
/// open and still does not.
#[must_use]
pub fn html(shown: usize, section: &str, gates: Gates) -> String {
    let sections = visible(gates);
    let shown = shown.min(sections.len() - 1);

    let mut strip = Slot::new(STRIP, RegionKind::TabGroup)
        .across(layout::Fallback::Menu)
        .showing_one(shown);

    for (at, section) in sections.iter().enumerate() {
        let mut region = Slot::bespoke(section.panel, "settings-panel").label(section.label);
        if at != shown {
            let mut call = Action::get(section.route).awaiting();
            // A described route names its own region and must be left to. Same
            // branch as the library strip, and it follows the switch rather than
            // the section: with `QUASI_SCREENS` unset the Askama route answers
            // and names nothing.
            if section.screen.is_none() {
                call = call.replacing(section.panel);
            }
            region = region.fed_by(call);
        }
        strip = strip.with(Node::Region(region));
    }

    use quasi_axum::Serves as _;

    Webview::new()
        .with_fill(sections[shown].panel, section)
        .fragment(&Node::Region(strip))
}

#[cfg(test)]
mod tests {
    use super::*;

    /// A reader every gate opens for.
    const ALL: Gates = Gates {
        has_media: true,
        git_enabled: true,
        has_mt_memberships: true,
        has_sync_apps: true,
    };

    /// A reader no gate opens for: Profile, Account and Creator Plan only.
    const NONE: Gates = Gates {
        has_media: false,
        git_enabled: false,
        has_mt_memberships: false,
        has_sync_apps: false,
    };

    /// The reader the older tests were written against: the three gates that
    /// existed before Cloud Sync, all open.
    const NO_SYNC: Gates = Gates {
        has_sync_apps: false,
        ..ALL
    };

    fn strip(gates: Gates) -> String {
        html(0, "<p>your profile</p>", gates)
    }

    #[test]
    fn the_settings_tab_still_opens_without_fetching() {
        // The nav included its first section rather than fetching it, and the
        // described strip keeps that: the shown frame arrives filled and the
        // other five are fetched on a press.
        let html = strip(NO_SYNC);

        assert!(!html.contains("hx-trigger=\"load\""), "{html}");
        assert!(html.contains("<p>your profile</p>"), "{html}");
        assert_eq!(html.matches("hx-get=").count(), 5, "{html}");
    }

    #[test]
    fn every_unshown_section_says_where_its_answer_lands() {
        let html = strip(NO_SYNC);

        // The Askama sections. `settings-ssh-keys` and `settings-forums` are
        // deliberately absent: both are described and name their own region, so
        // the strip must NOT retarget them. Until `64b33b26` they were here,
        // because the switch was off in tests and every section was Askama.
        for panel in ["settings-account", "settings-creator", "settings-media"] {
            assert!(html.contains(&format!("hx-target=\"#{panel}\"")), "{html}");
            assert!(html.contains(&format!("id=\"{panel}\"")), "{html}");
        }
        // Every section still gets its frame, described or not.
        for panel in ["settings-ssh-keys", "settings-forums"] {
            assert!(html.contains(&format!("id=\"{panel}\"")), "{html}");
            assert!(
                !html.contains(&format!("hx-target=\"#{panel}\"")),
                "{panel} is described and names its own region:\n{html}"
            );
        }
        assert!(!html.contains("hx-target=\"#settings-profile\""), "{html}");
    }

    #[test]
    fn a_described_section_is_left_to_name_its_own_region() {
        // Both described sections. The branch used to follow the switch rather
        // than the section, because with a screen off the Askama route answered
        // and named nothing; `64b33b26` deleted the switch, so being described
        // is the whole test now.
        let html = strip(NO_SYNC);

        for panel in ["settings-ssh-keys", "settings-forums"] {
            assert!(
                !html.contains(&format!("hx-target=\"#{panel}\"")),
                "a described section retargets its own answer:\n{html}"
            );
        }
        // An Askama neighbour is still told where its answer goes.
        assert!(html.contains("hx-target=\"#settings-account\""), "{html}");
    }

    #[test]
    fn the_two_screens_answer_into_the_frame_that_is_theirs() {
        // Both constants used to say `settings-body`, the single pane six
        // sections shared. If either drifts from the frame this strip draws for
        // it, that screen's answer lands nowhere.
        assert_eq!(super::super::ssh_keys::REGION, "settings-ssh-keys");
        assert_eq!(
            super::super::forum_memberships::SETTINGS_REGION,
            "settings-forums"
        );
    }

    #[test]
    fn a_deep_link_arrives_showing_the_section_it_asked_for() {
        // The whole of `3a7de032`: `?tab=settings&section=creator` opens the
        // Creator Plan filled rather than opening Profile and making the reader
        // find it.
        let all = NO_SYNC;
        let shown = shown_at(Some("creator"), all);
        assert_eq!(shown, 2);
        assert_eq!(section_at(shown, all), "creator");

        let html = html(shown, "<p>your plan</p>", all);
        assert!(html.contains("<p>your plan</p>"), "{html}");
        assert!(!html.contains("hx-target=\"#settings-creator\""), "{html}");
        // Profile is a press now, and it is the one the strip used to fill.
        assert!(html.contains("hx-target=\"#settings-profile\""), "{html}");
        assert!(html.contains("data-shows=\"2\""), "{html}");
    }

    #[test]
    fn a_section_the_page_cannot_fill_answers_profile() {
        // Real sections nothing links to, so nothing pays to render them inline.
        let all = ALL;
        assert_eq!(shown_at(Some("account"), all), 0);
        assert_eq!(shown_at(Some("media"), all), 0);
        assert_eq!(shown_at(Some("forums"), all), 0);
        // Not a section at all, and no section asked for.
        assert_eq!(shown_at(Some("nonsense"), all), 0);
        assert_eq!(shown_at(None, all), 0);
        // A gated section asked for by a reader who cannot see it. The index
        // shifts under the gate, so the answer has to be read as a name.
        assert_eq!(
            shown_at(
                Some("ssh-keys"),
                Gates {
                    git_enabled: false,
                    ..NO_SYNC
                }
            ),
            0
        );
        assert_eq!(
            section_at(
                0,
                Gates {
                    git_enabled: false,
                    ..NO_SYNC
                }
            ),
            "profile"
        );
        // ssh-keys is a described section, so `shown_at` answers profile for it
        // whether or not the reader can see it -- see the test below. The index
        // shift is still asserted, through `section_at`, which is what actually
        // does the reading.
        let git_only = Gates {
            git_enabled: true,
            ..NONE
        };
        assert_eq!(shown_at(Some("ssh-keys"), git_only), 0);
        assert_eq!(section_at(3, git_only), "ssh-keys");
    }

    #[test]
    fn a_described_section_is_not_fillable() {
        // A described section answers its own address through `quasi_router`,
        // which the page handler cannot call. Filling the frame with an Askama
        // rendering instead is not an option any more -- there is none -- so the
        // deep link opens Profile and the section is a press away.
        //
        // Was `a_switched_on_screen_is_not_fillable`, and carried a second case
        // for the switch being unset, where it filled at index 4. `64b33b26`
        // deleted the switch and the Askama rendering with it, so that case has
        // no way to arise.
        assert_eq!(shown_at(Some("ssh-keys"), NO_SYNC), 0);
    }

    #[test]
    fn a_shown_index_past_the_end_cannot_panic() {
        // A caller that computed an index against a different membership must
        // clamp rather than take the page down.
        let html = html(99, "<p>your profile</p>", NONE);
        assert!(html.contains("<p>your profile</p>"), "{html}");
        assert!(html.contains("data-shows=\"1\""), "{html}");
    }

    #[test]
    fn the_four_gated_sections_leave_when_their_test_fails() {
        const GATED: [&str; 4] = [
            ">Media</button>",
            ">SSH Keys</button>",
            ">Forums</button>",
            ">Cloud Sync</button>",
        ];

        let all = strip(ALL);
        for label in GATED {
            assert!(all.contains(label), "{all}");
        }

        let none = strip(NONE);
        for label in GATED {
            assert!(!none.contains(label), "{none}");
        }
        // The three ungated ones are still there, and the profile still arrives
        // with the document.
        assert_eq!(none.matches("hx-get=").count(), 2, "{none}");
        assert!(none.contains("<p>your profile</p>"), "{none}");
        assert!(none.contains("role=\"tablist\""), "{none}");
    }

    #[test]
    fn cloud_sync_is_absent_for_a_reader_who_owns_no_sync_app() {
        // The gate is the whole point of `47e67540` choosing a settings section
        // over a dashboard tab: Cloud Sync is for a developer shipping their own
        // software, so on nearly every account it is not there at all rather
        // than there and empty.
        let without = strip(NO_SYNC);
        assert!(!without.contains(">Cloud Sync</button>"), "{without}");
        assert!(!without.contains("id=\"settings-synckit\""), "{without}");

        let with = strip(ALL);
        assert!(with.contains(">Cloud Sync</button>"), "{with}");
        assert!(with.contains("id=\"settings-synckit\""), "{with}");
        // Askama, not a described screen, so the strip tells it where to land.
        assert!(with.contains("hx-target=\"#settings-synckit\""), "{with}");
        assert!(
            with.contains("hx-get=\"/dashboard/tabs/synckit\""),
            "{with}"
        );
    }

    #[test]
    fn the_stripe_return_lands_on_cloud_sync_filled() {
        // `synckit_return_url` sends a developer back to `&section=synckit`
        // after billing, and the point of that link is landing on the app they
        // were just billed for rather than on Profile.
        let owner = ALL;
        let shown = shown_at(Some("synckit"), owner);
        assert_eq!(section_at(shown, owner), "synckit");

        let html = html(shown, "<p>your apps</p>", owner);
        assert!(html.contains("<p>your apps</p>"), "{html}");
        assert!(!html.contains("hx-target=\"#settings-synckit\""), "{html}");
    }

    #[test]
    fn asking_for_cloud_sync_without_one_answers_profile() {
        // The gate shifts the index, so the reader who cannot see the section
        // gets Profile rather than whatever sits at Cloud Sync's old position.
        let stranger = NO_SYNC;
        assert_eq!(shown_at(Some("synckit"), stranger), 0);
        assert_eq!(
            section_at(shown_at(Some("synckit"), stranger), stranger),
            "profile"
        );
    }
}