//! Wire format for the builder form, and the page state the templates read.
//!
//! HTTP is stateless, so the whole draft travels with every interaction: each
//! already-added column and display column is posted back as a set of
//! parallel repeated fields. `serde_html_form` (via `axum_extra::extract::Form`)
//! decodes the repeats into `Vec`s, which `to_draft` zips back into a
//! [`TableDraft`].
//!
//! The column half of that form is the shared one — the field names here are
//! the same ones [`crate::schema::ColumnForm`] declares, and both are rebuilt
//! by [`crate::schema::columns_from_rows`], so the two screens that describe
//! columns cannot drift apart.

use crate::schema::{ColumnCatalog, ColumnDraft, columns_from_rows};

use super::draft::{
    ACCOUNT_API_COLUMN, ACCOUNTING_FIELD_TYPE, ACCOUNTING_TRANSFER_FIELD_TYPE, GeneratedAlias,
    TableDraft,
};

/// The `profile_name` option meaning "create a new profile too".
pub(crate) const NEW_PROFILE: &str = "__new__";

#[derive(Clone, Debug, Default, serde::Deserialize)]
pub(crate) struct BuilderForm {
    /// Which builder button was pressed. Empty on the initial page load.
    #[serde(default)]
    pub action: String,
    /// Row the action applies to, for the per-row buttons.
    #[serde(default)]
    pub index: Option<usize>,

    #[serde(default)]
    pub profile_name: String,
    #[serde(default)]
    pub profile_name_input: String,
    #[serde(default)]
    pub accounting_currency: String,
    #[serde(default)]
    pub rate_source_id: String,
    #[serde(default)]
    pub foreign_currencies: String,
    #[serde(default)]
    pub global: bool,
    #[serde(default)]
    pub table_name: String,

    // The pending column being described in the input panel.
    #[serde(default)]
    pub column_name_input: String,
    #[serde(default)]
    pub column_type_input: String,
    #[serde(default)]
    pub temporal_type_input: String,
    #[serde(default)]
    pub gtin_type_input: String,
    #[serde(default)]
    pub link_table_input: String,
    #[serde(default)]
    pub column_indexing_input: String,
    #[serde(default)]
    pub column_quantity_ledger_input: String,
    #[serde(default)]
    pub column_required_input: String,
    #[serde(default)]
    pub column_rounding_input: String,
    #[serde(default)]
    pub column_currency_input: String,

    // One entry per already-added column, in order.
    #[serde(default)]
    pub column_names: Vec<String>,
    #[serde(default)]
    pub column_types: Vec<String>,
    #[serde(default)]
    pub column_indexed: Vec<String>,
    #[serde(default)]
    pub column_quantity_ledger: Vec<String>,
    #[serde(default)]
    pub column_required: Vec<String>,
    #[serde(default)]
    pub column_rounding: Vec<String>,
    #[serde(default)]
    pub column_currencies: Vec<String>,

    // Tables the profile offers as link targets, in order.
    #[serde(default)]
    pub relation_tables: Vec<String>,

    #[serde(default)]
    pub row_display_columns: Vec<String>,

    // One pair per generated column offered an alias, in list order: the
    // generated column's own name, and what the user typed for it.
    #[serde(default)]
    pub generated_alias_sources: Vec<String>,
    #[serde(default)]
    pub generated_alias_names: Vec<String>,
}

impl BuilderForm {
    pub(crate) fn creating_new_profile(&self) -> bool {
        self.profile_name == NEW_PROFILE
    }

    /// Rebuilds the draft this form was rendered from.
    pub(crate) fn to_draft(&self) -> TableDraft {
        let creating_new_profile = self.creating_new_profile();

        let (added, ragged) = columns_from_rows(
            &self.column_names,
            &self.column_types,
            &self.column_indexed,
            &self.column_quantity_ledger,
            &self.column_required,
            &self.column_rounding,
            &self.column_currencies,
        );
        let columns = ColumnDraft {
            name_input: self.column_name_input.clone(),
            type_input: self.column_type_input.clone(),
            temporal_type_input: self.temporal_type_input.clone(),
            gtin_type_input: self.gtin_type_input.clone(),
            link_table_input: self.link_table_input.clone(),
            indexing_input: self.column_indexing_input.clone(),
            quantity_ledger_input: self.column_quantity_ledger_input.clone(),
            required_input: self.column_required_input.clone(),
            rounding_input: self.column_rounding_input.clone(),
            currency_input: self.column_currency_input.clone(),
            added,
            ragged,
            // Filled in by the loader from `ListColumnTypes`, never by the
            // form: it is the vocabulary the draft is validated against.
            catalog: ColumnCatalog::default(),
            // The table is being created here, so the creation-only types are
            // on the table.
            creating_table: true,
            // What the table will be, so the panel can hold a column to the
            // rules of the table it is being described for: a shared table
            // takes no column that posts to one profile's books, and no link
            // may point at the table being created.
            global: self.global,
            table_name: self.table_name.clone(),
        };

        // Drop display columns whose column is gone, so a stale post cannot
        // send a display column that no longer exists.
        let row_display_columns = self
            .row_display_columns
            .iter()
            .filter(|display| columns.added.iter().any(|column| &&column.name == display))
            .cloned()
            .collect();

        TableDraft {
            profile_name: if creating_new_profile {
                String::new()
            } else {
                self.profile_name.trim().to_string()
            },
            profile_name_input: self.profile_name_input.clone(),
            creating_new_profile,
            accounting_currency: self.accounting_currency.clone(),
            rate_source_id: self.rate_source_id.clone(),
            foreign_currencies: self.foreign_currencies.clone(),
            global: self.global,
            table_name: self.table_name.clone(),
            columns,
            relation_tables: self.relation_tables.clone(),
            relation_table_options: Vec::new(),
            row_display_columns,
            // Filled in by the loader from the live profile tree, never by the
            // client: it is what duplicate table names are checked against.
            existing_profile_tables: Vec::new(),
            // Which of these still name a generated column is the catalog's
            // answer, and the catalog is not filled in yet, so a pair is kept
            // here and matched up when the aliases are read.
            generated_aliases: self
                .generated_alias_sources
                .iter()
                .zip(self.generated_alias_names.iter())
                .map(|(source, alias)| GeneratedAlias {
                    source: source.trim().to_string(),
                    alias: alias.clone(),
                })
                .collect(),
        }
    }
}

/// What the page and the builder fragment render.
pub(crate) struct AddTablePageState {
    pub nav: crate::ui::Nav,
    pub profiles: Vec<String>,
    /// Provider IDs returned by ExchangeRateService.ListRateSources.
    pub rate_sources: Vec<String>,
    /// The profile a global table lands in, as the profile tree reports it.
    /// The builder posts it as the created table's scope.
    pub shared_profile: String,
    pub draft: TableDraft,
    /// The outcome of the last builder action, if any.
    pub status: Option<String>,
    pub error: Option<String>,
}

impl AddTablePageState {
    /// The value the profile `<select>` should show as chosen.
    pub(crate) fn selected_profile(&self) -> &str {
        if self.draft.creating_new_profile {
            NEW_PROFILE
        } else {
            &self.draft.profile_name
        }
    }

    /// The "Columns" list: every declared column, each followed by the columns
    /// it expands into.
    ///
    /// The expansion is flattened here rather than nested in the template so
    /// the markup stays one loop over one list, and so what a definition row
    /// brings is decided in one place.
    pub(crate) fn column_rows(&self) -> Vec<ColumnRow> {
        let columns = &self.draft.columns;
        let last_index = columns.added.len().saturating_sub(1);
        let mut rows = Vec::new();

        for (index, column) in columns.added.iter().enumerate() {
            // Whether it is indexed has a column of its own, so it is not
            // repeated here.
            let mut tags = Vec::new();
            if column.required {
                tags.push("required".to_string());
            }
            if column.quantity_ledger {
                tags.push("quantity ledger".to_string());
            }
            if !column.currency.is_empty() {
                tags.push(format!(
                    "{}, {}",
                    column.currency,
                    column.money_mode.label()
                ));
            }
            rows.push(ColumnRow {
                index: Some(index),
                first: index == 0,
                last: index == last_index,
                name: column.name.clone(),
                data_type: column.data_type.clone(),
                indexable: columns.is_indexable(index),
                // A link is indexed whether or not anyone asked: the server
                // builds an index for every foreign key.
                indexed: column.is_indexed(),
                tags,
                alias_source: None,
                alias: String::new(),
            });

            // Every generated column with persisted provenance may be named by
            // the request. Transfer connectors are still resolved by fixed
            // backend names and remain the exception.
            let aliasable = column.data_type != ACCOUNTING_TRANSFER_FIELD_TYPE;

            let generated_columns = columns.generated_columns_of(index);
            // Whether the backend already reports `account` as one of them, in
            // which case the foreign-key row below is a second view of a column
            // that is named once, not a column of its own to name again.
            let account_reported = generated_columns
                .iter()
                .any(|generated| generated.name == ACCOUNT_API_COLUMN);

            for generated in generated_columns {
                let mut tags = vec![format!("generated by {}", column.data_type)];
                if generated.inherits_currency {
                    tags.push(format!(
                        "{}, {}",
                        column.currency,
                        column.money_mode.label()
                    ));
                }
                rows.push(ColumnRow {
                    index: None,
                    first: false,
                    last: false,
                    name: generated.name.clone(),
                    data_type: generated.data_type.clone(),
                    indexable: false,
                    indexed: false,
                    tags,
                    alias_source: aliasable.then(|| generated.name.clone()),
                    alias: self.draft.alias_for(&generated.name).to_string(),
                });
            }

            // The physical column the account foreign key is stored in. It is
            // a system column, so it is listed whether or not the catalog
            // reports `account` among the generated ones — but it is named
            // there when it does, never twice.
            if column.data_type == ACCOUNTING_FIELD_TYPE {
                rows.push(ColumnRow {
                    index: None,
                    first: false,
                    last: false,
                    name: "account_id".to_string(),
                    data_type: "BIGINT".to_string(),
                    indexable: false,
                    indexed: true,
                    tags: vec![
                        "system column".to_string(),
                        format!(
                            "written as {}",
                            self.draft.generated_display_name(ACCOUNT_API_COLUMN)
                        ),
                    ],
                    alias_source: (!account_reported).then(|| ACCOUNT_API_COLUMN.to_string()),
                    alias: self.draft.alias_for(ACCOUNT_API_COLUMN).to_string(),
                });
            }
        }
        rows
    }

    /// The generated columns that may be renamed, in the order they are
    /// listed.
    ///
    /// Renaming lives in a section of its own rather than in the column list:
    /// the list is where the table is read, and a text box in every other row
    /// of it turns reading into scanning past inputs.
    /// One field per generated column and no more: a source named twice would
    /// be two fields over one column, and the draft reads the first of them,
    /// so whatever was typed in the second would be dropped without a word.
    pub(crate) fn alias_rows(&self) -> Vec<AliasRow> {
        let mut rows: Vec<AliasRow> = Vec::new();
        for row in self.column_rows() {
            let Some(source) = row.alias_source else {
                continue;
            };
            if rows.iter().any(|existing| existing.source == source) {
                continue;
            }
            rows.push(AliasRow {
                source,
                alias: row.alias,
                data_type: row.data_type,
            });
        }
        rows
    }

    /// Row-display candidates: `id` first, then every column the table will
    /// really hold.
    ///
    /// That includes the columns a definition row generates — they are columns
    /// like any other once the table exists, and the server accepts them here.
    /// The definition row itself is not among them: it leaves no column of its
    /// own name behind for a row to be shown by.
    ///
    /// The index is the candidate's place in this list, so the button that
    /// toggles one names the same column the label does however the list is
    /// filtered.
    pub(crate) fn row_display_candidates(&self) -> Vec<RowDisplayCandidate> {
        let mut candidates = vec![RowDisplayCandidate {
            index: 0,
            name: "id".to_string(),
            position: if self.draft.row_display_columns.is_empty() {
                Some(0)
            } else {
                None
            },
        }];
        for name in self.draft.row_display_column_names() {
            candidates.push(RowDisplayCandidate {
                index: candidates.len(),
                position: self.draft.row_display_position(&name),
                name,
            });
        }
        candidates
    }
}

/// One line of the "Columns" list: either a column the user declared, or one
/// the server will generate from the definition row above it.
pub(crate) struct ColumnRow {
    /// Where the column sits in the draft, for the buttons that act on it.
    /// `None` for a generated column, which is not the user's to act on: it
    /// moves and is removed with the definition row it came from.
    pub index: Option<usize>,
    /// Whether it can move any further up, and any further down.
    pub first: bool,
    pub last: bool,
    pub name: String,
    pub data_type: String,
    pub indexable: bool,
    pub indexed: bool,
    pub tags: Vec<String>,
    /// The generated column an alias would rename, when this row is one that
    /// may be aliased. `None` for a declared column — it is named where it is
    /// described — and for the columns the backend refuses to rename.
    pub alias_source: Option<String>,
    /// The alias typed for it so far.
    pub alias: String,
}

/// One line of the "Rename generated columns" section: a generated column the
/// request may name, and the name asked for it so far.
pub(crate) struct AliasRow {
    /// The generated column's own name, which is what the rename asks for.
    pub source: String,
    /// The alias typed for it, empty when the backend's name is being kept.
    pub alias: String,
    pub data_type: String,
}

pub(crate) struct RowDisplayCandidate {
    pub index: usize,
    pub name: String,
    /// `Some(0)` marks `id` as chosen; `Some(n)` is a column's 1-based place.
    pub position: Option<usize>,
}

impl RowDisplayCandidate {
    /// The selection mark, matching the client: a tick for `id`, otherwise the
    /// column's place in the display order.
    pub(crate) fn mark(&self) -> String {
        match self.position {
            Some(0) => "[x]".to_string(),
            Some(position) => format!("[{position}]"),
            None => "[ ]".to_string(),
        }
    }
}

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

    fn posted_form() -> BuilderForm {
        BuilderForm {
            profile_name: "billing".into(),
            table_name: "invoice".into(),
            column_names: vec!["number".into(), "total".into()],
            column_types: vec!["text".into(), "money".into()],
            column_indexed: vec!["yes".into(), "no".into()],
            column_quantity_ledger: vec!["no".into(), "no".into()],
            column_required: vec!["yes".into(), "no".into()],
            column_rounding: vec!["exact".into(), "half-up".into()],
            column_currencies: vec![String::new(), "EUR".into()],
            relation_tables: vec!["customer".into(), "project".into()],
            row_display_columns: vec!["number".into()],
            ..Default::default()
        }
    }

    #[test]
    fn round_trips_columns_relation_tables_and_display_columns() {
        let draft = posted_form().to_draft();

        assert_eq!(draft.columns.added.len(), 2);
        assert!(draft.columns.added[0].indexed);
        assert_eq!(draft.columns.added[1].money_mode, MoneyMode::Rounded);
        assert_eq!(draft.relation_tables, vec!["customer", "project"]);
        assert_eq!(draft.row_display_columns, vec!["number"]);
        assert!(!draft.creating_new_profile);
    }

    #[test]
    fn the_new_profile_option_switches_to_the_typed_name() {
        let mut form = posted_form();
        form.profile_name = NEW_PROFILE.to_string();
        form.profile_name_input = "  bookkeeping ".to_string();

        let draft = form.to_draft();

        assert!(draft.creating_new_profile);
        assert_eq!(draft.profile_name, "");
        assert_eq!(draft.effective_profile_name(), "bookkeeping");
    }

    #[test]
    fn mismatched_column_vectors_never_mis_pair() {
        let mut form = posted_form();
        form.column_types.pop();

        let draft = form.to_draft();

        assert_eq!(draft.columns.added.len(), 1);
        assert_eq!(draft.columns.added[0].name, "number");
        assert_eq!(draft.columns.added[0].data_type, "text");
    }

    #[test]
    fn display_columns_for_removed_columns_are_dropped() {
        let mut form = posted_form();
        form.row_display_columns = vec!["number".into(), "gone".into()];

        assert_eq!(form.to_draft().row_display_columns, vec!["number"]);
    }

    /// The column list shows a definition row with the columns it expands
    /// into. Only the definition row is the user's to act on: the generated
    /// ones carry no index, so they get no buttons.
    #[test]
    fn the_column_list_shows_what_a_definition_row_expands_into() {
        let mut page = AddTablePageState {
            nav: crate::ui::Nav::default(),
            shared_profile: "global".to_string(),
            profiles: Vec::new(),
            rate_sources: vec!["ecb".to_string()],
            draft: posted_form().to_draft(),
            status: None,
            error: None,
        };
        page.draft.columns.catalog = crate::schema::tests::catalog();
        page.draft
            .columns
            .added
            .push(crate::schema::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 rows = page.column_rows();
        assert_eq!(
            rows.iter().map(|row| row.name.as_str()).collect::<Vec<_>>(),
            [
                "number",
                "total",
                "accounting",
                "name",
                "tax_point_date",
                "debit",
                "credit",
                "account",
                "account_id",
            ]
        );

        let row = |name: &str| rows.iter().find(|row| row.name == name).unwrap();
        // Only the three declared columns can be moved, indexed or removed.
        assert_eq!(
            rows.iter().filter(|row| row.index.is_some()).count(),
            3,
            "only declared columns carry an index"
        );
        assert!(row("number").first);
        assert!(row("accounting").last);
        assert!(
            !row("accounting").indexable,
            "a definition row is no column"
        );
        assert!(row("debit").tags.contains(&"EUR, exact".to_string()));
        assert!(
            row("name")
                .tags
                .contains(&"generated by accounting".to_string())
        );
    }

    /// The generated columns of an ACCOUNTING row are the user's to alias, and
    /// the alias travels back with the rest of the draft.
    #[test]
    fn the_generated_columns_of_an_accounting_row_offer_an_alias() {
        let mut form = posted_form();
        form.column_names.push("accounting".into());
        form.column_types.push("accounting".into());
        form.column_indexed.push("no".into());
        form.column_quantity_ledger.push("no".into());
        form.column_required.push("no".into());
        form.column_rounding.push("exact".into());
        form.column_currencies.push("EUR".into());
        form.generated_alias_sources = vec!["debit".into(), "account".into()];
        form.generated_alias_names = vec!["Md 🙂".into(), "ucet".into()];

        let mut draft = form.to_draft();
        draft.columns.catalog = crate::schema::tests::catalog();

        assert_eq!(draft.alias_for("debit"), "Md 🙂");
        assert_eq!(
            draft.aliased_generated_columns(),
            vec![
                ("debit".to_string(), "Md 🙂".to_string()),
                ("account".to_string(), "ucet".to_string()),
            ]
        );

        let page = AddTablePageState {
            nav: crate::ui::Nav::default(),
            shared_profile: "global".to_string(),
            profiles: Vec::new(),
            rate_sources: vec!["ecb".to_string()],
            draft,
            status: None,
            error: None,
        };
        let rows = page.column_rows();
        let row = |name: &str| rows.iter().find(|row| row.name == name).unwrap();
        assert_eq!(row("Md 🙂").alias_source.as_deref(), Some("debit"));
        assert_eq!(row("Md 🙂").alias, "Md 🙂");
        // `account` is reported by the catalog, so it is named there and the
        // physical column it lands in is not offered a second field.
        assert_eq!(row("account").alias_source.as_deref(), Some("account"));
        assert_eq!(row("account").alias, "ucet");
        assert!(row("account_id").alias_source.is_none());
        assert!(
            row("account_id")
                .tags
                .contains(&"written as ucet".to_string())
        );
        assert!(
            row("accounting").alias_source.is_none(),
            "a declared column is named where it is described"
        );
    }

    #[test]
    fn the_draft_never_trusts_the_posted_table_list() {
        // `existing_profile_tables` is what duplicate-name checks read, so it
        // must come from the server, not the form.
        assert!(posted_form().to_draft().existing_profile_tables.is_empty());
    }
}