//! Dialogs used by the Annotate tab's table and drawing-data tools.
//!
//! The working state lives outside the drawing until the user presses OK or
//! Finish.  That keeps Cancel lossless and lets the wizard validate one page
//! before advancing to the next.

use std::collections::BTreeSet;
use std::fmt;

use acadrust::types::Handle;
use iced::widget::{button, checkbox, column, container, pick_list, row, scrollable, text, text_input, Space};
use iced::{Border, Element, Fill, Length, Theme};

use crate::app::Message;
use crate::t;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TableSource {
    #[default]
    Empty,
    DataLink,
    DataExtraction,
}

impl fmt::Display for TableSource {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::Empty => t!("Empty table").into_owned(),
            Self::DataLink => t!("Data link").into_owned(),
            Self::DataExtraction => t!("Data extraction").into_owned(),
        };
        f.write_str(&label)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum TableInsertion {
    #[default]
    Point,
    Window,
}

impl fmt::Display for TableInsertion {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::Point => t!("Specify insertion point").into_owned(),
            Self::Window => t!("Specify window").into_owned(),
        };
        f.write_str(&label)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DataLinkChoice {
    pub handle: Handle,
    pub name: String,
    pub path: String,
    pub valid: bool,
}

impl fmt::Display for DataLinkChoice {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.valid {
            write!(f, "🔗 {}", self.name)
        } else {
            write!(f, "⚠ {}", self.name)
        }
    }
}

#[derive(Debug, Clone)]
pub struct TableInsertState {
    pub styles: Vec<String>,
    pub style: String,
    pub source: TableSource,
    pub links: Vec<DataLinkChoice>,
    pub link: Option<DataLinkChoice>,
    pub insertion: TableInsertion,
    pub columns: String,
    pub data_rows: String,
    pub column_width: String,
    pub row_height: String,
    pub preview: bool,
    pub first_row_style: String,
    pub second_row_style: String,
    pub other_row_style: String,
    pub error: String,
}

impl Default for TableInsertState {
    fn default() -> Self {
        Self {
            styles: vec!["Standard".into()],
            style: "Standard".into(),
            source: TableSource::Empty,
            links: Vec::new(),
            link: None,
            insertion: TableInsertion::Point,
            columns: "3".into(),
            data_rows: "4".into(),
            column_width: "2.0".into(),
            row_height: "0.5".into(),
            preview: true,
            first_row_style: "Title".into(),
            second_row_style: "Header".into(),
            other_row_style: "Data".into(),
            error: String::new(),
        }
    }
}

#[derive(Debug, Clone)]
pub enum TableInsertField {
    Style(String),
    Source(TableSource),
    Link(DataLinkChoice),
    Insertion(TableInsertion),
    Columns(String),
    DataRows(String),
    ColumnWidth(String),
    RowHeight(String),
    Preview(bool),
    FirstRowStyle(String),
    SecondRowStyle(String),
    OtherRowStyle(String),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum LinkPathType {
    #[default]
    Full,
    Relative,
    FileName,
}

impl fmt::Display for LinkPathType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::Full => t!("Full path").into_owned(),
            Self::Relative => t!("Relative path").into_owned(),
            Self::FileName => t!("No path").into_owned(),
        };
        f.write_str(&label)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum LinkRange {
    #[default]
    EntireSheet,
    NamedRange,
    CellRange,
}

impl fmt::Display for LinkRange {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::EntireSheet => t!("Entire sheet").into_owned(),
            Self::NamedRange => t!("Named range").into_owned(),
            Self::CellRange => t!("Cell range").into_owned(),
        };
        f.write_str(&label)
    }
}

#[derive(Debug, Clone)]
pub struct DataLinkManagerState {
    pub links: Vec<DataLinkChoice>,
    pub selected: Option<DataLinkChoice>,
    pub editing: bool,
    pub editing_handle: Option<Handle>,
    pub name: String,
    pub path: String,
    pub path_type: LinkPathType,
    pub range_kind: LinkRange,
    pub range: String,
    pub sheets: Vec<String>,
    pub sheet: String,
    pub named_ranges: Vec<String>,
    pub allow_write: bool,
    pub use_source_formatting: bool,
    pub update_source_formatting: bool,
    pub insert_table: bool,
    pub more_options: bool,
    pub preview: Vec<Vec<String>>,
    pub status: String,
}

impl Default for DataLinkManagerState {
    fn default() -> Self {
        Self {
            links: Vec::new(),
            selected: None,
            editing: false,
            editing_handle: None,
            name: String::new(),
            path: String::new(),
            path_type: LinkPathType::Full,
            range_kind: LinkRange::EntireSheet,
            range: String::new(),
            sheets: Vec::new(),
            sheet: String::new(),
            named_ranges: Vec::new(),
            allow_write: false,
            use_source_formatting: true,
            update_source_formatting: true,
            insert_table: false,
            more_options: false,
            preview: Vec::new(),
            status: String::new(),
        }
    }
}

#[derive(Debug, Clone)]
pub enum DataLinkField {
    Name(String),
    Path(String),
    PathType(LinkPathType),
    RangeKind(LinkRange),
    Range(String),
    Sheet(String),
    AllowWrite(bool),
    UseSourceFormatting(bool),
    UpdateSourceFormatting(bool),
    InsertTable(bool),
    MoreOptions(bool),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ExtractionPage {
    #[default]
    Begin,
    Source,
    Objects,
    Properties,
    Refine,
    Output,
    TableStyle,
    Finish,
}

impl ExtractionPage {
    pub const fn number(self) -> usize {
        match self {
            Self::Begin => 1,
            Self::Source => 2,
            Self::Objects => 3,
            Self::Properties => 4,
            Self::Refine => 5,
            Self::Output => 6,
            Self::TableStyle => 7,
            Self::Finish => 8,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ExtractionBegin {
    #[default]
    New,
    Template,
    Edit,
}

impl fmt::Display for ExtractionBegin {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::New => t!("Create a new data extraction").into_owned(),
            Self::Template => t!("Use a previous extraction as a template").into_owned(),
            Self::Edit => t!("Edit an existing data extraction").into_owned(),
        };
        f.write_str(&label)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ExtractionSource {
    #[default]
    CurrentDrawing,
    CurrentSelection,
    DrawingsAndFolders,
}

impl fmt::Display for ExtractionSource {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            Self::CurrentDrawing => t!("Current drawing").into_owned(),
            Self::CurrentSelection => t!("Selected objects in current drawing").into_owned(),
            Self::DrawingsAndFolders => t!("Drawings / folders").into_owned(),
        };
        f.write_str(&label)
    }
}

#[derive(Debug, Clone)]
pub struct ExtractionObject {
    pub name: String,
    pub checked: bool,
    pub count: usize,
}

#[derive(Debug, Clone)]
pub struct ExtractionProperty {
    pub key: String,
    pub name: String,
    pub category: String,
    pub checked: bool,
}

#[derive(Debug, Clone)]
pub struct DataExtractionState {
    pub page: ExtractionPage,
    pub begin: ExtractionBegin,
    pub settings_path: String,
    pub source: ExtractionSource,
    pub include_current: bool,
    pub include_subfolders: bool,
    pub source_files: Vec<String>,
    pub selection_handles: Vec<Handle>,
    pub objects: Vec<ExtractionObject>,
    pub properties: Vec<ExtractionProperty>,
    pub categories: BTreeSet<String>,
    pub combine_identical: bool,
    pub show_count: bool,
    pub show_name: bool,
    pub preview: Vec<Vec<String>>,
    pub output_table: bool,
    pub output_file: bool,
    pub output_path: String,
    pub table_styles: Vec<String>,
    pub table_style: String,
    pub table_title: String,
    pub error: String,
}

impl Default for DataExtractionState {
    fn default() -> Self {
        Self {
            page: ExtractionPage::Begin,
            begin: ExtractionBegin::New,
            settings_path: String::new(),
            source: ExtractionSource::CurrentDrawing,
            include_current: true,
            include_subfolders: true,
            source_files: Vec::new(),
            selection_handles: Vec::new(),
            objects: Vec::new(),
            properties: vec![
                ExtractionProperty { key: "type".into(), name: "Type".into(), category: "General".into(), checked: true },
                ExtractionProperty { key: "handle".into(), name: "Handle".into(), category: "General".into(), checked: true },
                ExtractionProperty { key: "layer".into(), name: "Layer".into(), category: "General".into(), checked: true },
                ExtractionProperty { key: "color".into(), name: "Color".into(), category: "General".into(), checked: true },
                ExtractionProperty { key: "linetype".into(), name: "Linetype".into(), category: "General".into(), checked: true },
                ExtractionProperty { key: "details".into(), name: "Details".into(), category: "Geometry".into(), checked: true },
            ],
            categories: ["General".to_string(), "Geometry".to_string()].into_iter().collect(),
            combine_identical: false,
            show_count: true,
            show_name: true,
            preview: Vec::new(),
            output_table: true,
            output_file: false,
            output_path: String::new(),
            table_styles: vec!["Standard".into()],
            table_style: "Standard".into(),
            table_title: "Data Extraction".into(),
            error: String::new(),
        }
    }
}

#[derive(Debug, Clone)]
pub enum DataExtractionField {
    Begin(ExtractionBegin),
    SettingsPath(String),
    Source(ExtractionSource),
    IncludeCurrent(bool),
    IncludeSubfolders(bool),
    Object(usize, bool),
    Property(usize, bool),
    Category(String, bool),
    CombineIdentical(bool),
    ShowCount(bool),
    ShowName(bool),
    OutputTable(bool),
    OutputFile(bool),
    OutputPath(String),
    TableStyle(String),
    TableTitle(String),
}

fn muted(theme: &Theme) -> iced::widget::text::Style {
    iced::widget::text::Style {
        color: Some(theme.palette().background.base.text.scale_alpha(0.62)),
    }
}

fn group<'a>(title: impl Into<String>, body: Element<'a, Message>) -> Element<'a, Message> {
    container(column![text(title.into()).size(11).style(muted), body].spacing(7))
        .padding(9)
        .width(Fill)
        .style(|theme: &Theme| container::Style {
            border: Border { width: 1.0, radius: 4.0.into(), color: theme.palette().background.strong.color },
            ..Default::default()
        })
        .into()
}

fn labeled_input<'a>(label: impl Into<String>, value: &'a str, msg: fn(String) -> Message) -> Element<'a, Message> {
    row![text(label.into()).size(11).style(muted).width(118), text_input("", value).on_input(msg).padding([4, 7]).size(12).width(Fill)]
        .spacing(8).align_y(iced::Center).into()
}

fn cell_style_picker<'a>(
    label: impl Into<String>,
    selected: &'a str,
    msg: fn(String) -> Message,
) -> Element<'a, Message> {
    row![
        text(label.into()).size(11).style(muted).width(118),
        pick_list(
            Some(selected.to_string()),
            vec!["Title".to_string(), "Header".to_string(), "Data".to_string()],
            |value| value.clone(),
        )
        .on_select(msg)
        .padding([3, 6])
        .text_size(12)
        .width(Fill),
    ]
    .spacing(8)
    .align_y(iced::Center)
    .into()
}

fn radio_button<'a>(selected: bool, label: impl Into<String>, msg: Message) -> Element<'a, Message> {
    let mark = if selected { "◉" } else { "○" };
    button(row![text(mark).size(13), text(label.into()).size(12)].spacing(6))
        .on_press(msg).padding([4, 7]).style(button::text).into()
}

fn preview_grid<'a>(rows: &'a [Vec<String>]) -> Element<'a, Message> {
    if rows.is_empty() {
        return text(t!("No preview available.")).size(11).style(muted).into();
    }
    let lines = rows.iter().take(8).map(|row| row.join("  |  ")).collect::<Vec<_>>().join("\n");
    container(text(lines).size(11)).padding(6).width(Fill).into()
}

pub fn table_insert_view(state: &TableInsertState, sizing: crate::ui::modal::ModalSizing) -> Element<'_, Message> {
    let style = pick_list(Some(state.style.clone()), state.styles.clone(), |value| value.clone()).on_select(Message::TableInsertStyle).padding([3, 6]).text_size(12).width(Fill);
    let source = column![
        radio_button(state.source == TableSource::Empty, t!("Start from empty table"), Message::TableInsertField(TableInsertField::Source(TableSource::Empty))),
        radio_button(state.source == TableSource::DataLink, t!("Start from data link"), Message::TableInsertField(TableInsertField::Source(TableSource::DataLink))),
        radio_button(state.source == TableSource::DataExtraction, t!("Start from data extraction"), Message::TableInsertField(TableInsertField::Source(TableSource::DataExtraction))),
    ].spacing(1);
    let link_picker: Element<'_, Message> = if state.source == TableSource::DataLink {
        row![
            text(t!("Data link")).size(11).style(muted).width(118),
            pick_list(state.link.clone(), state.links.clone(), |value| value.to_string()).on_select(|value| Message::TableInsertField(TableInsertField::Link(value))).padding([3, 6]).text_size(12).width(Fill),
            button(text(t!("Manage…")).size(11)).on_press(Message::DataLinkManagerOpen).padding([4, 8]),
        ].spacing(8).align_y(iced::Center).into()
    } else { Space::new().height(0).into() };
    let insertion = column![
        radio_button(state.insertion == TableInsertion::Point, t!("Specify insertion point"), Message::TableInsertField(TableInsertField::Insertion(TableInsertion::Point))),
        radio_button(state.insertion == TableInsertion::Window, t!("Specify window"), Message::TableInsertField(TableInsertField::Insertion(TableInsertion::Window))),
    ];
    let settings = column![
        labeled_input(t!("Columns"), &state.columns, |v| Message::TableInsertField(TableInsertField::Columns(v))),
        labeled_input(t!("Column width"), &state.column_width, |v| Message::TableInsertField(TableInsertField::ColumnWidth(v))),
        labeled_input(t!("Data rows"), &state.data_rows, |v| Message::TableInsertField(TableInsertField::DataRows(v))),
        labeled_input(t!("Row height"), &state.row_height, |v| Message::TableInsertField(TableInsertField::RowHeight(v))),
    ].spacing(5);
    let cell_styles = column![
        cell_style_picker(t!("First row"), &state.first_row_style, |v| Message::TableInsertField(TableInsertField::FirstRowStyle(v))),
        cell_style_picker(t!("Second row"), &state.second_row_style, |v| Message::TableInsertField(TableInsertField::SecondRowStyle(v))),
        cell_style_picker(t!("All other rows"), &state.other_row_style, |v| Message::TableInsertField(TableInsertField::OtherRowStyle(v))),
    ].spacing(5);
    column![
        group(t!("Table style"), row![style].into()),
        group(t!("Insert options"), column![source, link_picker].spacing(4).into()),
        row![group(t!("Insertion behavior"), insertion.into()), group(t!("Column & row settings"), settings.into())].spacing(8),
        group(t!("Set cell styles"), cell_styles.into()),
        checkbox(state.preview).label(t!("Preview")).on_toggle(|v| Message::TableInsertField(TableInsertField::Preview(v))).size(14),
        text(&state.error).size(11),
        row![Space::new().width(Fill), button(text(t!("Cancel")).size(12)).on_press(Message::CloseModal).padding([5, 12]), button(text(t!("OK")).size(12)).on_press(Message::TableInsertApply).style(button::primary).padding([5, 12])].spacing(7),
    ].spacing(8).padding(10).width(sizing.width).height(sizing.height).into()
}

pub fn data_link_view(state: &DataLinkManagerState, sizing: crate::ui::modal::ModalSizing) -> Element<'_, Message> {
    let mut links = column![text(t!("Spreadsheet Links")).size(11).style(muted)].spacing(2);
    links = links.push(button(text(t!("Create a New Data Link")).size(12)).on_press(Message::DataLinkNew).padding([5, 7]).style(button::text).width(Fill));
    for link in &state.links {
        let selected = state.selected.as_ref().is_some_and(|v| v.handle == link.handle);
        let label = if selected { format!("● {link}") } else { format!("  {link}") };
        links = links.push(button(text(label).size(12)).on_press(Message::DataLinkSelect(link.handle)).padding([5, 7]).style(button::text).width(Fill));
    }
    let tree = container(scrollable(links).height(Fill)).padding(6).width(Length::Fixed(220.0)).height(Fill);
    let right: Element<'_, Message> = if state.editing {
        let mut editor = column![
            labeled_input(t!("Data link name"), &state.name, |v| Message::DataLinkField(DataLinkField::Name(v))),
            row![text(t!("File")).size(11).style(muted).width(118), text_input("", &state.path).on_input(|v| Message::DataLinkField(DataLinkField::Path(v))).padding([4, 7]).size(12).width(Fill), button(text("…")).on_press(Message::DataLinkBrowse).padding([4, 9])].spacing(6).align_y(iced::Center),
            row![text(t!("Path type")).size(11).style(muted).width(118), pick_list(Some(state.path_type), vec![LinkPathType::Full, LinkPathType::Relative, LinkPathType::FileName], |value| value.to_string()).on_select(|value| Message::DataLinkField(DataLinkField::PathType(value))).width(Fill).padding([3, 6])].spacing(8),
            row![text(t!("Link option")).size(11).style(muted).width(118), pick_list(Some(state.range_kind), vec![LinkRange::EntireSheet, LinkRange::NamedRange, LinkRange::CellRange], |value| value.to_string()).on_select(|value| Message::DataLinkField(DataLinkField::RangeKind(value))).width(Fill).padding([3, 6])].spacing(8),
        ].spacing(6);
        if !state.sheets.is_empty() && state.range_kind != LinkRange::NamedRange {
            editor = editor.push(row![
                text(t!("Sheet")).size(11).style(muted).width(118),
                pick_list(Some(state.sheet.clone()), state.sheets.clone(), |value| value.clone())
                    .on_select(|value| Message::DataLinkField(DataLinkField::Sheet(value)))
                    .width(Fill)
                    .padding([3, 6]),
            ].spacing(8));
        }
        if state.range_kind == LinkRange::NamedRange && !state.named_ranges.is_empty() {
            editor = editor.push(row![
                text(t!("Named range")).size(11).style(muted).width(118),
                pick_list(Some(state.range.clone()), state.named_ranges.clone(), |value| value.clone())
                    .on_select(|value| Message::DataLinkField(DataLinkField::Range(value)))
                    .width(Fill)
                    .padding([3, 6]),
            ].spacing(8));
        } else if state.range_kind != LinkRange::EntireSheet {
            editor = editor.push(labeled_input(t!("Range"), &state.range, |v| Message::DataLinkField(DataLinkField::Range(v))));
        }
        editor = editor.push(checkbox(state.more_options).label(t!("More options")).on_toggle(|v| Message::DataLinkField(DataLinkField::MoreOptions(v))).size(14));
        if state.more_options {
            editor = editor
                .push(checkbox(state.allow_write).label(t!("Allow writing to source file")).on_toggle(|v| Message::DataLinkField(DataLinkField::AllowWrite(v))).size(14))
                .push(checkbox(state.use_source_formatting).label(t!("Use source formatting")).on_toggle(|v| Message::DataLinkField(DataLinkField::UseSourceFormatting(v))).size(14))
                .push(checkbox(state.update_source_formatting).label(t!("Keep table updated to source formatting")).on_toggle(|v| Message::DataLinkField(DataLinkField::UpdateSourceFormatting(v))).size(14));
        }
        editor = editor.push(checkbox(state.insert_table).label(t!("Insert table after saving link")).on_toggle(|v| Message::DataLinkField(DataLinkField::InsertTable(v))).size(14));
        group(t!("Link settings"), editor.into())
    } else if let Some(link) = &state.selected {
        column![
            group(t!("Details"), column![text(format!("{}: {}", t!("Name"), link.name)).size(11), text(format!("{}: {}", t!("File"), link.path)).size(11), text(if link.valid { t!("Status: Linked") } else { t!("Status: Source not found") }).size(11)].spacing(5).into()),
            group(t!("Preview"), preview_grid(&state.preview)),
        ].spacing(8).into()
    } else {
        group(t!("Details"), text(t!("Select a data link or create a new one.")).size(11).style(muted).into())
    };
    let actions = if state.editing {
        row![Space::new().width(Fill), button(text(t!("Cancel")).size(12)).on_press(Message::DataLinkEditCancel).padding([5, 11]), button(text(t!("OK")).size(12)).on_press(Message::DataLinkSave).style(button::primary).padding([5, 11])].spacing(7)
    } else {
        let enabled = state.selected.is_some();
        let edit = button(text(t!("Edit")).size(12)).padding([5, 11]);
        let delete = button(text(t!("Delete")).size(12)).padding([5, 11]);
        let insert = button(text(t!("Insert Table")).size(12)).padding([5, 11]);
        row![if enabled { edit.on_press(Message::DataLinkEdit) } else { edit }, if enabled { delete.on_press(Message::DataLinkDelete) } else { delete }, Space::new().width(Fill), if enabled { insert.on_press(Message::DataLinkInsert) } else { insert }, button(text(t!("Close")).size(12)).on_press(Message::DataLinkClose).padding([5, 11])].spacing(7)
    };
    column![row![tree, container(right).width(Fill).height(Fill)].spacing(8).height(Fill), text(&state.status).size(11), actions]
        .spacing(7).padding(10).width(sizing.width).height(sizing.height).into()
}

fn wizard_nav(state: &DataExtractionState) -> iced::widget::Row<'_, Message> {
    let back = button(text(t!("Back")).size(12)).padding([5, 12]);
    let next = button(text(if state.page == ExtractionPage::Finish { t!("Finish") } else { t!("Next") }).size(12)).padding([5, 12]).style(button::primary);
    row![Space::new().width(Fill), if state.page == ExtractionPage::Begin { back } else { back.on_press(Message::DataExtractionBack) }, button(text(t!("Cancel")).size(12)).on_press(Message::CloseModal).padding([5, 12]), if state.error.is_empty() { next.on_press(if state.page == ExtractionPage::Finish { Message::DataExtractionFinish } else { Message::DataExtractionNext }) } else { next }].spacing(7)
}

pub fn data_extraction_view(state: &DataExtractionState, sizing: crate::ui::modal::ModalSizing) -> Element<'_, Message> {
    let body: Element<'_, Message> = match state.page {
        ExtractionPage::Begin => group(t!("Begin"), column![
            radio_button(state.begin == ExtractionBegin::New, t!("Create a new data extraction"), Message::DataExtractionField(DataExtractionField::Begin(ExtractionBegin::New))),
            radio_button(state.begin == ExtractionBegin::Template, t!("Use a previous extraction as a template"), Message::DataExtractionField(DataExtractionField::Begin(ExtractionBegin::Template))),
            radio_button(state.begin == ExtractionBegin::Edit, t!("Edit an existing data extraction"), Message::DataExtractionField(DataExtractionField::Begin(ExtractionBegin::Edit))),
            row![text(t!("Extraction settings")).size(11).style(muted).width(118), text_input("", &state.settings_path).on_input(|v| Message::DataExtractionField(DataExtractionField::SettingsPath(v))).padding([4, 7]).size(12).width(Fill), button(text("…")).on_press(Message::DataExtractionBrowseSettings).padding([4, 9])].spacing(6).align_y(iced::Center),
        ].spacing(5).into()),
        ExtractionPage::Source => group(t!("Define data source"), column![
            radio_button(state.source == ExtractionSource::CurrentDrawing, t!("Current drawing"), Message::DataExtractionField(DataExtractionField::Source(ExtractionSource::CurrentDrawing))),
            radio_button(state.source == ExtractionSource::CurrentSelection, t!("Select objects in the current drawing"), Message::DataExtractionField(DataExtractionField::Source(ExtractionSource::CurrentSelection))),
            radio_button(state.source == ExtractionSource::DrawingsAndFolders, t!("Drawings / folders"), Message::DataExtractionField(DataExtractionField::Source(ExtractionSource::DrawingsAndFolders))),
            checkbox(state.include_current).label(t!("Include current drawing")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::IncludeCurrent(v))).size(14),
            checkbox(state.include_subfolders).label(t!("Include subfolders")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::IncludeSubfolders(v))).size(14),
            row![
                button(text(t!("Add drawings…")).size(12)).on_press(Message::DataExtractionAddDrawings).padding([5, 10]),
                button(text(t!("Add folder…")).size(12)).on_press(Message::DataExtractionAddFolder).padding([5, 10]),
                button(text(t!("Clear")).size(12)).on_press(Message::DataExtractionClearSources).padding([5, 10]),
            ].spacing(6),
            text(state.source_files.join("\n")).size(10),
        ].spacing(6).into()),
        ExtractionPage::Objects => {
            let mut list = column![].spacing(3);
            for (i, item) in state.objects.iter().enumerate() {
                list = list.push(checkbox(item.checked).label(format!("{}  ({})", item.name, item.count)).on_toggle(move |v| Message::DataExtractionField(DataExtractionField::Object(i, v))).size(14));
            }
            group(t!("Select objects"), scrollable(list).height(Fill).into())
        }
        ExtractionPage::Properties => {
            let mut categories = row![].spacing(10);
            for category in ["General", "Geometry"] {
                let checked = state.categories.contains(category);
                let key = category.to_string();
                categories = categories.push(checkbox(checked).label(category).on_toggle(move |v| Message::DataExtractionField(DataExtractionField::Category(key.clone(), v))).size(14));
            }
            let mut list = column![categories].spacing(4);
            for (i, item) in state.properties.iter().enumerate().filter(|(_, p)| state.categories.contains(&p.category)) {
                list = list.push(checkbox(item.checked).label(format!("{}  ·  {}", item.name, item.category)).on_toggle(move |v| Message::DataExtractionField(DataExtractionField::Property(i, v))).size(14));
            }
            group(t!("Select properties"), scrollable(list).height(Fill).into())
        }
        ExtractionPage::Refine => group(t!("Refine data"), column![
            row![checkbox(state.combine_identical).label(t!("Combine identical rows")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::CombineIdentical(v))).size(14), checkbox(state.show_count).label(t!("Show count column")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::ShowCount(v))).size(14), checkbox(state.show_name).label(t!("Show name column")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::ShowName(v))).size(14)].spacing(12),
            scrollable(preview_grid(&state.preview)).height(Fill),
        ].spacing(8).into()),
        ExtractionPage::Output => group(t!("Choose output"), column![
            checkbox(state.output_table).label(t!("Insert data extraction table into drawing")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::OutputTable(v))).size(14),
            checkbox(state.output_file).label(t!("Output data to external file")).on_toggle(|v| Message::DataExtractionField(DataExtractionField::OutputFile(v))).size(14),
            row![text(t!("Output file")).size(11).style(muted).width(118), text_input("", &state.output_path).on_input(|v| Message::DataExtractionField(DataExtractionField::OutputPath(v))).padding([4, 7]).size(12).width(Fill), button(text("…")).on_press(Message::DataExtractionBrowseOutput).padding([4, 9])].spacing(6).align_y(iced::Center),
        ].spacing(7).into()),
        ExtractionPage::TableStyle => group(t!("Table style"), column![
            row![text(t!("Style")).size(11).style(muted).width(118), pick_list(Some(state.table_style.clone()), state.table_styles.clone(), |value| value.clone()).on_select(|value| Message::DataExtractionField(DataExtractionField::TableStyle(value))).padding([3, 6]).width(Fill)].spacing(8),
            labeled_input(t!("Title"), &state.table_title, |v| Message::DataExtractionField(DataExtractionField::TableTitle(v))),
            preview_grid(&state.preview),
        ].spacing(7).into()),
        ExtractionPage::Finish => group(t!("Finish"), column![text(t!("The selected drawing data is ready to be extracted.")).size(12), text(format!("{}: {}", t!("Rows"), state.preview.len().saturating_sub(1))).size(11), text(format!("{}: {}{}", t!("Output"), if state.output_table { t!("Drawing table") } else { "".into() }, if state.output_file { format!("  {}", t!("External file")) } else { String::new() })).size(11)].spacing(7).into()),
    };
    column![
        text(format!("{}  {}/8", t!("Data Extraction"), state.page.number())).size(13),
        container(body).height(Fill).width(Fill),
        text(&state.error).size(11),
        wizard_nav(state),
    ].spacing(8).padding(10).width(sizing.width).height(sizing.height).into()
}