use askama::Template;

use crate::{
    {i18n::Locale, tr},
    schema::CURRENCY_CODES,
    ui::{Alert, Nav, render},
};

use super::state::AddTablePageState;

/// GET /admin/tables/new — the page shell around the builder.
#[derive(Template)]
#[template(path = "pages/add_table/add_table.html")]
struct AddTablePage<'a> {
    nav: Nav,
    page: &'a AddTablePageState,
    column_types: Vec<String>,
    temporal_types: Vec<String>,
    gtin_types: Vec<String>,
    currency_codes: &'static [&'static str],
}

/// POST /admin/tables/builder — the `#builder` swap, which is the same markup
/// the page embeds, so one template serves both.
#[derive(Template)]
#[template(path = "pages/add_table/builder.html")]
struct BuilderFragment<'a> {
    nav: Nav,
    page: &'a AddTablePageState,
    column_types: Vec<String>,
    temporal_types: Vec<String>,
    gtin_types: Vec<String>,
}

pub(crate) fn render_page(page: &AddTablePageState) -> String {
    render(&AddTablePage {
        nav: page.nav.clone(),
        page,
        // Every picker is the backend's own vocabulary, asked through the
        // draft so it can only offer what the draft would accept.
        column_types: page.draft.columns.offered_types(),
        temporal_types: page.draft.columns.temporal_types(),
        gtin_types: page.draft.columns.gtin_types(),
        currency_codes: CURRENCY_CODES,
    })
}

pub(crate) fn render_builder(page: &AddTablePageState) -> String {
    render(&BuilderFragment {
        nav: page.nav.clone(),
        page,
        column_types: page.draft.columns.offered_types(),
        temporal_types: page.draft.columns.temporal_types(),
        gtin_types: page.draft.columns.gtin_types(),
    })
}

/// Used when the page itself cannot be loaded (auth or backend failure).
/// There is no draft left to render, so this replaces the builder — the dialog
/// is what tells the user why the form just emptied.
pub(crate) fn render_submission_error(locale: Locale, message: &str) -> String {
    render(&Alert::error(
        locale,
        &tr!(locale, "builder-err-title"),
        message,
    ))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        pages::add_table::draft::{RelationTableOption, TableDraft},
        schema::{ColumnDefinition, MoneyMode},
    };

    fn page() -> AddTablePageState {
        let mut draft = TableDraft::new();
        draft.columns.catalog = crate::schema::tests::catalog();
        draft.profile_name = "billing".to_string();
        draft.table_name = "invoice".to_string();
        draft.columns.added.push(ColumnDefinition {
            name: "number".to_string(),
            data_type: "text".to_string(),
            indexed: true,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: String::new(),
        });
        draft.set_available_relation_table_options(vec![
            RelationTableOption {
                name: "customer".to_string(),
                global: false,
                system: false,
            },
            RelationTableOption {
                name: "currencies".to_string(),
                global: true,
                system: false,
            },
            RelationTableOption {
                name: "audit_log".to_string(),
                global: false,
                system: true,
            },
        ]);
        draft.toggle_row_display_candidate(1);

        AddTablePageState {
            nav: Nav::default(),
            shared_profile: "__global".to_string(),
            profiles: vec!["billing".to_string()],
            rate_sources: vec!["ecb".to_string()],
            draft,
            status: None,
            error: None,
        }
    }

    /// `render` turns a template failure into an error string rather than
    /// panicking, so the markup has to be asserted on.
    #[test]
    fn the_builder_carries_the_whole_draft_and_the_preview() {
        let html = render_builder(&page());

        assert!(!html.contains("Template error"), "{html}");
        // Every part of the draft travels with the next request.
        assert!(html.contains(r#"name="column_names" value="number""#));
        assert!(html.contains(r#"name="column_indexed" value="yes""#));
        assert!(html.contains(r#"name="relation_tables" value="customer""#));
        assert!(html.contains(r#"name="row_display_columns" value="number""#));
        // The preview shows the schema as it will exist.
        assert!(html.contains("BIGSERIAL"));
        assert!(html.contains("TIMESTAMPTZ"));
    }

    /// The columns an ACCOUNTING row generates get a name field of their own,
    /// which is what makes them aliasable at creation time — in a section of
    /// their own, not in the column list, which is there to be read.
    #[test]
    fn generated_accounting_columns_get_an_alias_field() {
        let mut page = page();
        page.draft.columns.added.push(ColumnDefinition {
            name: "accounting".to_string(),
            data_type: "accounting".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: "EUR".to_string(),
        });

        let html = render_builder(&page);

        assert!(!html.contains("Template error"), "{html}");
        for generated in ["name", "tax_point_date", "debit", "credit", "account"] {
            assert!(
                html.contains(&format!(
                    r#"<input type="hidden" name="generated_alias_sources" value="{generated}">"#
                )),
                "`{generated}` should be aliasable"
            );
        }
        assert!(html.contains(r#"name="generated_alias_names""#));
        // The column list itself carries no input at all.
        let list = html
            .split("<h2>Columns")
            .nth(1)
            .and_then(|rest| rest.split("</table>").next())
            .expect("the column list should be rendered");
        assert!(!list.contains("<input"), "{list}");
        assert!(html.contains("<summary>Rename generated columns</summary>"));
    }

    /// A rename is reported where the column is listed, so the list still says
    /// what the table will look like without the section being opened.
    #[test]
    fn a_renamed_generated_column_says_so_in_the_column_list() {
        let mut page = page();
        page.draft.columns.added.push(ColumnDefinition {
            name: "accounting".to_string(),
            data_type: "accounting".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: "EUR".to_string(),
        });
        page.draft.generated_aliases = vec![crate::pages::add_table::draft::GeneratedAlias {
            source: "debit".to_string(),
            alias: "md".to_string(),
        }];

        let html = render_builder(&page);

        assert!(html.contains(r#"<span class="tag">renamed to md</span>"#), "{html}");
        assert!(html.contains(r#"name="generated_alias_names" value="md""#));
        // The names only reach the column list when something posts them, and
        // the section stays open so the applied names can be read back.
        assert!(html.contains(r#""action": "apply-generated-names""#));
        assert!(html.contains(r#"<details class="rename-generated" open>"#));
    }

    /// With no name asked for, the section is the closed default it was.
    #[test]
    fn the_rename_section_starts_closed() {
        let mut page = page();
        page.draft.columns.added.push(ColumnDefinition {
            name: "accounting".to_string(),
            data_type: "accounting".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: "EUR".to_string(),
        });

        let html = render_builder(&page);

        assert!(html.contains(r#"<details class="rename-generated" >"#), "{html}");
    }

    #[test]
    fn the_page_offers_backend_vocabularies_for_profile_setup() {
        let html = render_page(&page());

        assert!(!html.contains("Template error"), "{html}");
        assert!(html.contains(r#"value="__new__""#));
        assert!(html.contains(r#"<datalist id="currency-codes">"#));
        assert!(html.contains(r#"<option value="EUR">"#));
        assert!(html.contains(r#"<datalist id="rate-source-ids">"#));
        assert!(html.contains(r#"<option value="ecb">"#));
    }

    #[test]
    fn the_scope_picker_explains_profile_and_shared_tables() {
        let html = render_builder(&page());

        assert!(html.contains("Where should this table be available?"));
        assert!(html.contains(r#"name="global" value="false""#));
        assert!(html.contains(r#"name="global" value="true""#));
        assert!(html.contains("Which profile?"));
        assert!(html.contains("Only the selected profile can use this table."));
        assert!(html.contains("Every profile can use this shared table."));
    }

    /// Every type the server accepts has to be reachable from the picker, or
    /// the web UI silently offers less than the backend does.
    #[test]
    fn the_type_picker_offers_interval_and_accounting_types() {
        let html = render_builder(&page());

        for column_type in ["duration", "period", "accounting"] {
            assert!(
                html.contains(&format!(r#"<option value="{column_type}""#)),
                "the type picker is missing {column_type}"
            );
        }
    }

    #[test]
    fn conditional_fields_follow_the_pending_column_type() {
        let mut state = page();
        assert!(!render_builder(&state).contains(r#"name="temporal_type_input""#));

        state.draft.columns.type_input = "temporal".to_string();
        let html = render_builder(&state);
        assert!(html.contains(r#"name="temporal_type_input""#));
        assert!(!html.contains(r#"name="gtin_type_input""#));

        state.draft.columns.type_input = "gtin".to_string();
        assert!(render_builder(&state).contains(r#"name="gtin_type_input""#));

        // Money reveals its currency and rounding inputs.
        state.draft.columns.type_input = "money".to_string();
        let html = render_builder(&state);
        assert!(html.contains(r#"name="column_rounding_input""#));
        assert!(html.contains(r#"list="currency-codes""#));

        state.draft.columns.type_input = "link".to_string();
        let html = render_builder(&state);
        assert!(html.contains(r#">FKlink</option>"#));
        assert!(html.contains("Link alias"));
        assert!(html.contains(r#"name="link_table_input""#));
        assert!(html.contains(r#"<option value="customer""#));
        assert!(html.contains(r#"<optgroup label="Global">"#));
        assert!(html.contains(r#"<optgroup label="User-created">"#));
        assert!(html.contains(r#"<optgroup label="System-created">"#));
    }

    /// Choosing a compound type says what it will add, instead of leaving the
    /// choice to be discovered after the table exists.
    #[test]
    fn choosing_accounting_shows_the_columns_it_will_generate() {
        let mut state = page();
        assert!(!render_builder(&state).contains("compound-note"));

        state.draft.columns.type_input = "accounting".to_string();
        let html = render_builder(&state);

        assert!(html.contains("compound-note"));
        for generated in ["name", "tax_point_date", "debit", "credit", "account_id"] {
            assert!(
                html.contains(&format!("<code>{generated}</code>")),
                "the note is missing {generated}"
            );
        }
        // A definition row is named after its own type, so there is nothing to
        // type in and nothing to index.
        assert!(!html.contains(r#"name="column_name_input""#));
        assert!(!html.contains(r#"name="column_indexing_input""#));
        // It does declare the currency its DEBIT and CREDIT are kept in.
        assert!(html.contains(r#"name="column_currency_input""#));
    }

    /// The column list can be reordered, and the ends say so by refusing.
    #[test]
    fn columns_carry_move_buttons_that_stop_at_the_ends() {
        let mut state = page();
        state.draft.columns.added.push(ColumnDefinition {
            name: "total".to_string(),
            data_type: "money".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: "EUR".to_string(),
        });

        let html = render_builder(&state);

        assert!(html.contains(r#""action": "move-column-down", "index": "0""#));
        assert!(html.contains(r#""action": "move-column-up", "index": "1""#));
        // The first column cannot move up, nor the last one down.
        assert!(!html.contains(r#""action": "move-column-up", "index": "0""#));
        assert!(!html.contains(r#""action": "move-column-down", "index": "1""#));
        assert_eq!(html.matches("disabled").count(), 2);
    }

    /// And an added definition row is listed with the columns it stands for.
    #[test]
    fn the_column_list_shows_generated_columns_under_their_definition_row() {
        let mut state = page();
        state.draft.columns.added.push(ColumnDefinition {
            name: "accounting".to_string(),
            data_type: "accounting".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: "EUR".to_string(),
        });

        let html = render_builder(&state);

        assert!(html.contains("generated-row"));
        assert!(html.contains("generated by accounting"));
        assert!(html.contains("<code>tax_point_date</code>"));
        // A generated column is not the user's to remove: the definition row
        // is the only one of the two with a Remove button.
        assert_eq!(html.matches("remove-column").count(), 2);
    }

    #[test]
    fn the_new_profile_fields_appear_only_for_a_new_profile() {
        let mut state = page();
        assert!(!render_builder(&state).contains(r#"name="profile_name_input" value"#));

        state.draft.creating_new_profile = true;
        let html = render_builder(&state);
        assert!(html.contains(r#"name="profile_name_input""#));
        assert!(html.contains(r#"name="accounting_currency""#));
        assert!(html.contains(r#"list="currency-codes""#));
        assert!(html.contains(r#"name="rate_source_id""#));
        assert!(html.contains(r#"list="rate-source-ids""#));
        let foreign_currency_input = html
            .split(r#"name="foreign_currencies""#)
            .nth(1)
            .and_then(|rest| rest.split('>').next())
            .expect("the initial foreign-currency input should be rendered");
        assert!(foreign_currency_input.contains(r#"list="currency-codes""#));
    }

    /// The dialog only exists when there is a failure, and it carries the same
    /// message as the inline alert behind it.
    #[test]
    fn a_failure_is_shown_as_a_dialog_as_well_as_an_alert() {
        let mut state = page();
        assert!(!render_builder(&state).contains(r#"role="dialog""#));

        state.error = Some("That column already exists.".to_string());
        let html = render_builder(&state);
        assert!(html.contains(r#"role="dialog""#));
        assert!(html.contains("x-data=\"{ dangerModalIsOpen: true }\""));
        assert_eq!(html.matches("That column already exists.").count(), 2);
    }

    /// The dialog is Tailwind + Alpine, so the page has to load them; the
    /// `head` block lives two levels up, in `ui/base.html`.
    #[test]
    fn the_page_loads_what_the_dialog_needs() {
        let html = render_page(&page());

        assert!(html.contains("@tailwindcss/browser@4"));
        assert!(html.contains("@alpinejs/focus@3"));
        assert!(html.contains("htmx:beforeSwap"));
    }

    /// Choosing FKlink takes the Indexing choice away and says who makes the
    /// index instead. Offering the choice is what sent a definition the server
    /// refuses outright — a link is indexed automatically.
    #[test]
    fn choosing_a_link_replaces_the_index_choice_with_who_makes_it() {
        let mut state = page();
        assert!(render_builder(&state).contains(r#"name="column_indexing_input""#));

        state.draft.columns.type_input = "link".to_string();
        let html = render_builder(&state);

        assert!(!html.contains(r#"name="column_indexing_input""#), "{html}");
        assert!(html.contains("Indexed automatically"));
        // The rest of the link's own fields are still there.
        assert!(html.contains(r#"name="link_table_input""#));
        assert!(html.contains("Link alias"));
    }

    /// And a link already in the list is reported as indexed, without a toggle
    /// that would do nothing.
    #[test]
    fn a_link_in_the_column_list_is_shown_as_indexed_by_the_server() {
        let mut state = page();
        state.draft.columns.added.push(ColumnDefinition {
            name: "billing_customer".to_string(),
            data_type: "link(customer)".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: String::new(),
        });

        let html = render_builder(&state);

        assert!(html.contains("indexed automatically"), "{html}");
        // `number` keeps its toggle; the link is offered none.
        assert!(html.contains(r#""action": "toggle-index", "index": "0""#));
        assert!(!html.contains(r#""action": "toggle-index", "index": "1""#));
    }

    /// A column can be made required, and the answer travels with the draft.
    #[test]
    fn a_column_can_be_required_and_says_so_in_the_list() {
        let mut state = page();
        assert!(render_builder(&state).contains(r#"name="column_required_input""#));

        state.draft.columns.added[0].required = true;
        let html = render_builder(&state);

        assert!(html.contains(r#"name="column_required" value="yes""#));
        assert!(html.contains(r#"<span class="tag">required</span>"#));
    }

    /// A shared table keeps no books, so the columns that post to a profile's
    /// books are not on offer and the page says why.
    #[test]
    fn the_shared_scope_offers_no_column_that_belongs_to_one_profile() {
        let mut state = page();
        state.draft.global = true;
        state.draft.columns.global = true;

        let html = render_builder(&state);

        assert!(!html.contains(r#"<option value="accounting""#), "{html}");
        assert!(!html.contains(r#"<option value="accounting_transfer""#));
        assert!(!html.contains(r#"name="column_quantity_ledger_input""#));
        assert!(html.contains("A shared table keeps no books of its own"));
        // Everything else is still offered.
        assert!(html.contains(r#"<option value="money""#));
    }

    /// A row is identified by the columns the table will really hold, which
    /// includes what a definition row generates.
    #[test]
    fn generated_columns_can_identify_a_row() {
        let mut state = page();
        state.draft.columns.added.push(ColumnDefinition {
            name: "accounting".to_string(),
            data_type: "accounting".to_string(),
            indexed: false,
            quantity_ledger: false,
            required: false,
            money_mode: MoneyMode::Exact,
            currency: "EUR".to_string(),
        });

        let candidates = state
            .row_display_candidates()
            .into_iter()
            .map(|candidate| candidate.name)
            .collect::<Vec<_>>();

        assert_eq!(
            candidates,
            [
                "id",
                "number",
                "name",
                "tax_point_date",
                "debit",
                "credit",
                "account"
            ]
        );
        // The definition row is not one of them, having no column of its name.
        assert!(!candidates.contains(&"accounting".to_string()));
    }

    /// A load failure has no draft to render, so the dialog is the response.
    #[test]
    fn a_load_failure_answers_with_the_dialog() {
        let html = render_submission_error(crate::i18n::Locale::default(), "The backend is unreachable.");

        assert!(!html.contains("Template error"), "{html}");
        assert!(html.contains(r#"role="dialog""#));
        assert!(html.contains("The backend is unreachable."));
    }

}