//! Plot Style Table Editor window — fills the entire OS window.

use crate::app::Message;
use crate::t;
use crate::ui::style::common::muted_style;
use crate::ui::style::form::{field_style, hdivider, vsep};
use iced::widget::{button, column, container, row, scrollable, text, text_input, Space};
use iced::{Background, Border, Element, Theme};
use std::borrow::Cow;
use std::fmt;

#[derive(Clone, Debug, PartialEq)]
struct PlotLineweightItem {
    index: u8,
    label: String,
}

impl fmt::Display for PlotLineweightItem {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.label)
    }
}

fn plot_lineweight_options() -> Vec<PlotLineweightItem> {
    let mut options = vec![PlotLineweightItem {
        index: 255,
        label: t!("Use object lineweight").into_owned(),
    }];

    options.extend(
        crate::io::plot_style::LW_TABLE
            .iter()
            .enumerate()
            .map(|(index, lw)| PlotLineweightItem {
                index: index as u8,
                label: format!("{lw:.2} mm"),
            }),
    );

    options
}

fn btn_s(accent: bool) -> impl Fn(&Theme, button::Status) -> button::Style {
    move |theme: &Theme, st| {
        let palette = theme.palette();
        let pair = match (accent, st) {
            (true, button::Status::Hovered | button::Status::Pressed) => palette.primary.strong,
            (false, button::Status::Hovered | button::Status::Pressed) => palette.background.strong,
            (true, _) => palette.primary.base,
            _ => palette.background.weak,
        };
        button::Style {
            background: Some(Background::Color(pair.color)),
            text_color: pair.text,
            border: Border {
                color: palette.background.neutral.color,
                width: 1.0,
                radius: 4.0.into(),
            },
            ..Default::default()
        }
    }
}

/// Layer names bucketed by ACI (AutoCAD Color Index), index = ACI.
///
/// Pure function of `document.layers`: one entry per layer whose color is
/// `Color::Index(aci)` with `1 <= aci < 256`, each bucket sorted
/// case-insensitively. Extracted from `view_window` so the table can be
/// unit-tested and benched without building widgets. `pub` (not
/// `pub(crate)`) so the `cargo bench` harness (`benches/`, an external
/// crate) can measure it as `ui_plotstyle_layer_usage`.
pub fn build_layer_usage(document: &codec::CadDocument) -> Vec<Vec<String>> {
    let mut layer_usage = vec![Vec::<String>::new(); 256];

    for layer in document.layers.iter() {
        if let codec::types::Color::Index(aci) = &layer.color {
            let index = *aci as usize;

            if index > 0 && index < layer_usage.len() {
                layer_usage[index].push(layer.name.clone());
            }
        }
    }

    for layers in &mut layer_usage {
        if layers.len() > 1 {
            layers.sort_by_cached_key(|name| name.to_ascii_lowercase());
        }
    }
    layer_usage
}

pub fn view_window<'a>(
    document: &'a codec::CadDocument,
    table: Option<&'a crate::io::plot_style::PlotStyleTable>,
    selected_aci: u8,
    color_buf: &'a str,
    lw_buf: &'a str,
    screen_buf: &'a str,
    sizing: crate::ui::modal::ModalSizing,
) -> Element<'a, Message> {
    let show_layer_usage = !table.is_some_and(|table| table.is_stb);

    let layer_usage = if show_layer_usage {
        build_layer_usage(document)
    } else {
        Vec::new()
    };
    let table_name = table
        .map(|t| t.name.clone())
        .unwrap_or_else(|| t!("(no table loaded)").into_owned());

    // ── Toolbar ───────────────────────────────────────────────────────────
    let toolbar = container(
        row![
            button(text(t!("Load CTB/STB")).size(11))
                .on_press(Message::PlotStyleLoad)
                .style(btn_s(false))
                .padding([4, 10]),
            button(text(t!("Save")).size(11))
                .on_press(Message::PlotStylePanelSaveDirect)
                .style(btn_s(true))
                .padding([4, 14]),
            button(text(t!("Save As…")).size(11))
                .on_press(Message::PlotStylePanelSave)
                .style(btn_s(false))
                .padding([4, 10]),
            button(text(t!("Clear Table")).size(11))
                .on_press(Message::PlotStyleClear)
                .style(btn_s(false))
                .padding([4, 10]),
            Space::new().width(sizing.width),
            text(table_name).size(10).style(muted_style),
        ]
        .spacing(4)
        .align_y(iced::Center),
    )
    .style(|theme: &Theme| container::Style {
        background: Some(Background::Color(theme.palette().background.weak.color)),
        ..Default::default()
    })
    .width(sizing.width)
    .padding([5, 8]);

    // ── Left: ACI list ────────────────────────────────────────────────────
    let aci_items: Vec<Element<'_, Message>> = (1u8..=255)
        .map(|aci| {
            let is_sel = aci == selected_aci;
            let usage_count = layer_usage.get(aci as usize).map(Vec::len).unwrap_or(0);

            let usage_label = if show_layer_usage && usage_count > 0 {
                format!("● {usage_count}")
            } else {
                String::new()
            };
            let (aci_color, _) =
                crate::ui::properties::acad_color_display(codec::types::Color::Index(aci));
            let has_override = table
                .and_then(|t| t.aci_entries.get(aci as usize))
                .map(|e| e.color.is_some() || e.lineweight != 255 || e.screening != 100)
                .unwrap_or(false);
            let lw_str = table
                .and_then(|t| t.aci_entries.get(aci as usize))
                .and_then(|e| {
                    if e.lineweight != 255 {
                        crate::io::plot_style::LW_TABLE
                            .get(e.lineweight as usize)
                            .map(|lw| format!("{lw:.2}mm"))
                    } else {
                        None
                    }
                })
                .unwrap_or_default();
            let color_str = table
                .and_then(|t| t.aci_entries.get(aci as usize))
                .and_then(|e| e.color.map(|[r, g, b]| format!("#{r:02X}{g:02X}{b:02X}")))
                .unwrap_or_default();
            let label = if has_override {
                format!("{aci:>3}  {color_str:<9} {lw_str}")
            } else {
                format!("{aci:>3}  {}", t!("(default)"))
            };
            button(
                row![
                    crate::ui::color_select::swatch(aci_color),
                    text(label)
                        .size(10)
                        .font(iced::Font::MONOSPACE)
                        .width(iced::Length::Fill),
                    text(usage_label)
                        .size(10)
                        .font(iced::Font::MONOSPACE)
                        .width(42),
                ]
                .spacing(6)
                .align_y(iced::Center),
            )
            .on_press(Message::PlotStylePanelSelectAci(aci))
            .style(move |theme: &Theme, st| {
                let palette = theme.palette();
                let pair = match (is_sel, st) {
                    (true, _) => Some(palette.primary.strong),
                    (false, button::Status::Hovered | button::Status::Pressed) => {
                        Some(palette.background.strong)
                    }
                    _ => None,
                };
                button::Style {
                    background: pair.map(|p| Background::Color(p.color)),
                    text_color: pair.map(|p| p.text).unwrap_or(palette.background.base.text),
                    ..Default::default()
                }
            })
            .padding([2, 8])
            .width(sizing.width)
            .into()
        })
        .collect();

    let aci_list = container(
        column![
            row![
                text(t!("ACI Color Index"))
                    .size(10)
                    .style(muted_style)
                    .width(iced::Length::Fill),
                text(t!("Layers")).size(10).style(muted_style).width(42),
            ]
            .align_y(iced::Center),
            container(scrollable(column(aci_items).spacing(1)).height(sizing.height))
                .style(|theme: &Theme| {
                    let palette = theme.palette();
                    container::Style {
                        background: Some(Background::Color(palette.background.weak.color)),
                        border: Border {
                            color: palette.background.neutral.color,
                            width: 1.0,
                            radius: 3.0.into(),
                        },
                        ..Default::default()
                    }
                })
                .width(sizing.width)
                .height(sizing.height)
                .padding(2),
        ]
        .spacing(4)
        .height(sizing.height),
    )
    .width(280)
    .height(sizing.height)
    .padding(iced::Padding {
        top: 12.0,
        right: 8.0,
        bottom: 12.0,
        left: 12.0,
    });

    // ── Right: Edit panel ─────────────────────────────────────────────────
    let selected_layers = layer_usage
        .get(selected_aci as usize)
        .cloned()
        .unwrap_or_default();

    let selected_layers_text = if selected_layers.is_empty() {
        t!("(none)").into_owned()
    } else {
        selected_layers.join(", ")
    };
    let entry = table.and_then(|t| t.aci_entries.get(selected_aci as usize));
    let cur_color = entry
        .and_then(|e| e.color.map(|[r, g, b]| format!("#{r:02X}{g:02X}{b:02X}")))
        .unwrap_or_else(|| t!("(none)").into());
    let cur_lw = entry
        .map(|e| {
            if e.lineweight == 255 {
                t!("object").into()
            } else {
                crate::io::plot_style::LW_TABLE
                    .get(e.lineweight as usize)
                    .map(|lw| crate::tf!("{lw:.2}mm (idx {})", e.lineweight).into_owned())
                    .unwrap_or_else(|| crate::tf!("idx {}", e.lineweight).into_owned())
            }
        })
        .unwrap_or_else(|| "—".into());
    let cur_scr = entry
        .map(|e| format!("{}%", e.screening))
        .unwrap_or_else(|| "—".into());

    let lbl = |s: Cow<'static, str>| text(s).size(11).style(muted_style);
    let lw_items = plot_lineweight_options();

    let current_lw_index = lw_buf.trim().parse::<u8>().unwrap_or(255);

    let current_lw = lw_items
        .iter()
        .find(|item| item.index == current_lw_index)
        .cloned()
        .unwrap_or_else(|| lw_items[0].clone());

    let edit_panel = container(
        column![
            row![
                text(t!("ACI:")).size(11).style(muted_style).width(100),
                text(format!("{selected_aci}")).size(11),
            ]
            .spacing(8)
            .align_y(iced::Center),
            if show_layer_usage {
                container(
                    column![
                        text(format!("{}: {}", t!("Layers"), selected_layers.len()))
                            .size(10)
                            .style(muted_style),
                        text(selected_layers_text)
                            .size(10)
                            .width(iced::Length::Fill),
                    ]
                    .spacing(3),
                )
                .padding([5, 8])
                .width(iced::Length::Fill)
            } else {
                container(Space::new().height(0))
            },
            // ── Plot color ───────────────────────────────────────────────────
            lbl(t!("Plot color:")),
            {
                let selected_color = color_buf
                    .strip_prefix('#')
                    .filter(|hex| hex.len() == 6)
                    .and_then(|hex| u32::from_str_radix(hex, 16).ok())
                    .map(|rgb| codec::types::Color::Rgb {
                        r: ((rgb >> 16) & 0xFF) as u8,
                        g: ((rgb >> 8) & 0xFF) as u8,
                        b: (rgb & 0xFF) as u8,
                    });

                let display_color =
                    selected_color.unwrap_or(codec::types::Color::Index(selected_aci));

                let (swatch_color, _) = crate::ui::properties::acad_color_display(display_color);

                let display_text = if color_buf.is_empty() {
                    t!("Use object color").into_owned()
                } else {
                    crate::ui::color_select::color_display_name(display_color)
                };

                row![
                    container(
                        row![
                            crate::ui::color_select::swatch(swatch_color),
                            text(display_text).size(11),
                        ]
                        .spacing(6)
                        .align_y(iced::Center)
                    )
                    .padding([4, 8])
                    .width(iced::Length::Fill),
                    button(text(t!("Choose color…")).size(11))
                        .on_press(Message::OpenColorWindow(
                            crate::app::ColorPickTarget::PlotStyle,
                            display_color,
                        ))
                        .style(btn_s(false))
                        .padding([4, 10]),
                    button(text(t!("Reset")).size(11))
                        .on_press(Message::PlotStylePanelColorBuf(String::new()))
                        .style(btn_s(false))
                        .padding([4, 10]),
                ]
                .spacing(6)
                .align_y(iced::Center)
            },
            // ── Lineweight ───────────────────────────────────────────────────
            lbl(t!("Lineweight:")),
            iced::widget::pick_list(Some(current_lw), lw_items, |item| item.to_string(),)
                .on_select(|item: PlotLineweightItem| { Message::PlotStylePanelLwSet(item.index) })
                .text_size(11)
                .padding([3, 5])
                .width(iced::Length::Fill),
            // ── Screening ────────────────────────────────────────────────────
            lbl(t!("Screening (0-100):")),
            text_input("100", screen_buf)
                .on_input(Message::PlotStylePanelScreenBuf)
                .style(field_style)
                .size(11)
                .padding([4, 8]),
            Space::new().height(8),
            // ── Current values ───────────────────────────────────────────────
            text(t!("Current values:")).size(10).style(muted_style),
            text(t!("  Color: %{cur_color}", cur_color = cur_color)).size(10),
            text(t!("  Lineweight: %{cur_lw}", cur_lw = cur_lw)).size(10),
            text(t!("  Screening: %{cur_scr}", cur_scr = cur_scr)).size(10),
            Space::new().height(12),
            hdivider(iced::Length::Fill),
            Space::new().height(8),
            if show_layer_usage {
                container(
                    column![
                        row![
                            text(crate::tf!("Layers using ACI {selected_aci}")).size(11),
                            Space::new().width(iced::Length::Fill),
                            text(format!(
                                "{} {}",
                                selected_layers.len(),
                                if selected_layers.len() == 1 {
                                    t!("layer")
                                } else {
                                    t!("layers")
                                }
                            ))
                            .size(10)
                            .style(muted_style),
                        ]
                        .align_y(iced::Center),
                        if selected_layers.is_empty() {
                            column![text(t!("No layers use this ACI in the current drawing."))
                                .size(10)
                                .style(muted_style)]
                        } else {
                            column(
                                selected_layers
                                    .iter()
                                    .map(|name| text(format!("• {name}")).size(10).into())
                                    .collect::<Vec<Element<'_, Message>>>(),
                            )
                            .spacing(4)
                        },
                    ]
                    .spacing(7),
                )
                .padding([8, 4])
                .width(iced::Length::Fill)
            } else {
                container(Space::new().height(0))
            },
            Space::new().height(sizing.height),
        ]
        .spacing(8)
        .height(sizing.height),
    )
    .width(sizing.width)
    .height(sizing.height)
    .padding([12, 12]);

    let body = row![aci_list, vsep(sizing.height), edit_panel].height(sizing.height);

    container(column![toolbar, hdivider(sizing.width), body].spacing(0))
        .style(|theme: &Theme| container::Style {
            background: Some(Background::Color(theme.palette().background.base.color)),
            ..Default::default()
        })
        .width(sizing.width)
        .height(sizing.height)
        .into()
}

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

    fn indexed_layer(doc: &mut codec::CadDocument, name: &str, aci: u8) -> codec::tables::Layer {
        let mut layer = codec::tables::Layer::new(name);
        layer.handle = doc.allocate_handle();
        layer.color = codec::types::Color::Index(aci);
        layer
    }

    #[test]
    fn build_layer_usage_buckets_index_colors() {
        let mut doc = codec::CadDocument::new();
        let a = indexed_layer(&mut doc, "WALLS", 1);
        let b = indexed_layer(&mut doc, "doors", 1);
        let c = indexed_layer(&mut doc, "ROOF", 3);
        let _ = doc.layers.add(a);
        let _ = doc.layers.add(b);
        let _ = doc.layers.add(c);

        let usage = build_layer_usage(&doc);

        assert_eq!(usage.len(), 256);
        assert_eq!(usage[1], vec!["doors".to_string(), "WALLS".to_string()]);
        assert_eq!(usage[3], vec!["ROOF".to_string()]);
        assert!(usage[2].is_empty());
    }

    #[test]
    fn build_layer_usage_ignores_non_index_colors() {
        let mut doc = codec::CadDocument::new();
        let mut truecolor = codec::tables::Layer::new("TRUECOLOR");
        truecolor.handle = doc.allocate_handle();
        truecolor.color = codec::types::Color::Rgb {
            r: 10,
            g: 20,
            b: 30,
        };
        let _ = doc.layers.add(truecolor);

        let usage = build_layer_usage(&doc);

        assert!(
            usage
                .iter()
                .all(|bucket| !bucket.iter().any(|n| n == "TRUECOLOR")),
            "truecolor layer must not appear in any ACI bucket"
        );
    }
}