// Copyright 2022 System76 <info@system76.com>
// SPDX-License-Identifier: MPL-2.0

use cosmic::{
    iced::{self, wayland::window::set_mode_window, Application, Command, Length},
    iced::{
        wayland::window::{start_drag_window, toggle_maximize},
        widget::{column, container, horizontal_space, pick_list, progress_bar, row, slider},
        window,
    },
    theme::{self, Theme},
    widget::{
        button, header_bar, nav_bar, nav_bar_toggle,
        rectangle_tracker::{rectangle_tracker_subscription, RectangleTracker, RectangleUpdate},
        scrollable, segmented_button, settings, toggler, IconSource,
    },
    Element, ElementExt,
};
use std::{
    sync::atomic::{AtomicU32, Ordering},
    vec,
};
use theme::Button as ButtonTheme;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Page {
    Demo,
    WiFi,
    Networking,
    Bluetooth,
    Desktop,
    InputDevices,
    Displays,
    PowerAndBattery,
    Sound,
    PrintersAndScanners,
    PrivacyAndSecurity,
    SystemAndAccounts,
    UpdatesAndRecovery,
    TimeAndLanguage,
    Accessibility,
    Applications,
}

impl Page {
    //TODO: translate
    pub fn title(&self) -> &'static str {
        use Page::*;
        match self {
            Demo => "Demo",
            WiFi => "Wi-Fi",
            Networking => "Networking",
            Bluetooth => "Bluetooth",
            Desktop => "Desktop",
            InputDevices => "Input Devices",
            Displays => "Displays",
            PowerAndBattery => "Power & Battery",
            Sound => "Sound",
            PrintersAndScanners => "Printers & Scanners",
            PrivacyAndSecurity => "Privacy & Security",
            SystemAndAccounts => "System & Accounts",
            UpdatesAndRecovery => "Updates & Recovery",
            TimeAndLanguage => "Time & Language",
            Accessibility => "Accessibility",
            Applications => "Applications",
        }
    }

    pub fn icon_name(&self) -> &'static str {
        use Page::*;
        match self {
            Demo => "document-properties-symbolic",
            WiFi => "network-wireless-symbolic",
            Networking => "network-workgroup-symbolic",
            Bluetooth => "bluetooth-active-symbolic",
            Desktop => "video-display-symbolic",
            InputDevices => "input-keyboard-symbolic",
            Displays => "preferences-desktop-display-symbolic",
            PowerAndBattery => "battery-full-charged-symbolic",
            Sound => "multimedia-volume-control-symbolic",
            PrintersAndScanners => "printer-symbolic",
            PrivacyAndSecurity => "preferences-system-privacy-symbolic",
            SystemAndAccounts => "system-users-symbolic",
            UpdatesAndRecovery => "software-update-available-symbolic",
            TimeAndLanguage => "preferences-system-time-symbolic",
            Accessibility => "preferences-desktop-accessibility-symbolic",
            Applications => "preferences-desktop-apps-symbolic",
        }
    }
}

impl Default for Page {
    fn default() -> Page {
        //TODO: what should the default page be?
        Page::Desktop
    }
}

static WINDOW_WIDTH: AtomicU32 = AtomicU32::new(0);
const BREAK_POINT: u32 = 900;

#[derive(Default)]
pub struct Window {
    title: String,
    page: Page,
    debug: bool,
    theme: Theme,
    slider_value: f32,
    checkbox_value: bool,
    toggler_value: bool,
    pick_list_selected: Option<&'static str>,
    nav_bar_pages: segmented_button::SingleSelectModel,
    nav_bar_toggled_condensed: bool,
    nav_bar_toggled: bool,
    show_minimize: bool,
    show_maximize: bool,
    exit: bool,
    rectangle_tracker: Option<RectangleTracker<u32>>,
}

impl Window {
    /// Adds a page to the model we use for the navigation bar.
    fn insert_page(&mut self, page: Page) -> segmented_button::SingleSelectEntityMut {
        self.nav_bar_pages
            .insert()
            .text(page.title())
            .icon(IconSource::from(page.icon_name()))
            .data(page)
    }

    fn is_condensed(&self) -> bool {
        WINDOW_WIDTH.load(Ordering::Relaxed) < BREAK_POINT
    }

    pub fn nav_bar_toggled(mut self, toggled: bool) -> Self {
        self.nav_bar_toggled = toggled;
        self
    }

    fn page(&mut self, page: Page) {
        self.nav_bar_toggled_condensed = false;
        self.page = page;
    }

    pub fn show_maximize(mut self, show: bool) -> Self {
        self.show_maximize = show;
        self
    }

    pub fn show_minimize(mut self, show: bool) -> Self {
        self.show_minimize = show;
        self
    }
}

#[allow(dead_code)]
#[derive(Clone, Debug)]
pub enum Message {
    Page(Page),
    Debug(bool),
    ThemeChanged(Theme),
    ButtonPressed,
    SliderChanged(f32),
    CheckboxToggled(bool),
    TogglerToggled(bool),
    PickListSelected(&'static str),
    RowSelected(usize),
    Close,
    ToggleNavBar,
    ToggleNavBarCondensed,
    Drag,
    Minimize,
    Maximize,
    InputChanged,
    Rectangle(RectangleUpdate<u32>),
    NavBar(segmented_button::Entity),
    Ignore,
}

impl Application for Window {
    type Executor = iced::executor::Default;
    type Flags = ();
    type Message = Message;
    type Theme = Theme;

    fn new(_flags: ()) -> (Self, Command<Self::Message>) {
        let mut window = Window::default()
            .nav_bar_toggled(true)
            .show_maximize(true)
            .show_minimize(true);
        window.slider_value = 50.0;
        //        window.theme = Theme::Light;
        window.pick_list_selected = Some("Option 1");
        window.title = String::from("COSMIC Design System - Iced");

        window.insert_page(Page::Demo);
        window.insert_page(Page::WiFi);
        window.insert_page(Page::Networking);
        window.insert_page(Page::Bluetooth);
        window.insert_page(Page::Desktop).activate();
        window.insert_page(Page::InputDevices);
        window.insert_page(Page::Displays);
        window.insert_page(Page::PowerAndBattery);
        window.insert_page(Page::Sound);
        window.insert_page(Page::PrintersAndScanners);
        window.insert_page(Page::PrivacyAndSecurity);
        window.insert_page(Page::SystemAndAccounts);
        window.insert_page(Page::TimeAndLanguage);
        window.insert_page(Page::Accessibility);
        window.insert_page(Page::Applications);

        (window, Command::none())
    }

    fn title(&self) -> String {
        self.title.clone()
    }

    fn update(&mut self, message: Message) -> iced::Command<Self::Message> {
        match message {
            Message::NavBar(key) => {
                if let Some(page) = self.nav_bar_pages.data::<Page>(key).cloned() {
                    self.nav_bar_pages.activate(key);
                    self.page(page);
                }
            }
            Message::Page(page) => self.page = page,
            Message::Debug(debug) => self.debug = debug,
            Message::ThemeChanged(theme) => self.theme = theme,
            Message::ButtonPressed => {}
            Message::SliderChanged(value) => self.slider_value = value,
            Message::CheckboxToggled(value) => {
                self.checkbox_value = value;
            }
            Message::TogglerToggled(value) => self.toggler_value = value,
            Message::PickListSelected(value) => self.pick_list_selected = Some(value),
            Message::Close => self.exit = true,
            Message::ToggleNavBar => self.nav_bar_toggled = !self.nav_bar_toggled,
            Message::ToggleNavBarCondensed => {
                self.nav_bar_toggled_condensed = !self.nav_bar_toggled_condensed
            }
            Message::Drag => return start_drag_window(window::Id(0)),
            Message::Minimize => return set_mode_window(window::Id(0), window::Mode::Hidden),
            Message::Maximize => return toggle_maximize(window::Id(0)),
            Message::RowSelected(row) => println!("Selected row {row}"),
            Message::InputChanged => {}
            Message::Rectangle(r) => match r {
                RectangleUpdate::Rectangle(r) => {
                    dbg!(r);
                }
                RectangleUpdate::Init(t) => {
                    self.rectangle_tracker.replace(t);
                }
            },
            Message::Ignore => {}
        }

        Command::none()
    }

    fn view(&self, _: window::Id) -> Element<Message> {
        let (nav_bar_message, nav_bar_toggled) = if self.is_condensed() {
            (
                Message::ToggleNavBarCondensed,
                self.nav_bar_toggled_condensed,
            )
        } else {
            (Message::ToggleNavBar, self.nav_bar_toggled)
        };

        let mut header = header_bar()
            .title("COSMIC Design System - Iced")
            .on_close(Message::Close)
            .on_drag(Message::Drag)
            .start(
                nav_bar_toggle()
                    .on_nav_bar_toggled(nav_bar_message)
                    .nav_bar_active(nav_bar_toggled)
                    .into(),
            );

        if self.show_maximize {
            header = header.on_maximize(Message::Maximize);
        }

        if self.show_minimize {
            header = header.on_minimize(Message::Minimize);
        }

        let header = Into::<Element<Message>>::into(header).debug(self.debug);

        let mut widgets = Vec::with_capacity(2);

        if nav_bar_toggled {
            let mut nav_bar = nav_bar(&self.nav_bar_pages, Message::NavBar);

            if !self.is_condensed() {
                nav_bar = nav_bar.max_width(300);
            }

            let nav_bar: Element<_> = nav_bar.into();
            widgets.push(nav_bar.debug(self.debug));
        }

        if !(self.is_condensed() && nav_bar_toggled) {
            let secondary = button(ButtonTheme::Secondary)
                .text("Secondary")
                .on_press(Message::ButtonPressed);

            let secondary = if let Some(tracker) = self.rectangle_tracker.as_ref() {
                tracker.container(0, secondary).into()
            } else {
                secondary.into()
            };
            let content: Element<_> = settings::view_column(vec![
                settings::view_section("Debug")
                    .add(settings::item(
                        "Debug layout",
                        toggler(String::from("Debug layout"), self.debug, Message::Debug),
                    ))
                    .into(),
                settings::view_section("Buttons")
                    .add(settings::item_row(vec![
                        button(ButtonTheme::Primary)
                            .text("Primary")
                            .on_press(Message::ButtonPressed)
                            .into(),
                        secondary,
                        button(ButtonTheme::Positive)
                            .text("Positive")
                            .on_press(Message::ButtonPressed)
                            .into(),
                        button(ButtonTheme::Destructive)
                            .text("Destructive")
                            .on_press(Message::ButtonPressed)
                            .into(),
                        button(ButtonTheme::Text)
                            .text("Text")
                            .on_press(Message::ButtonPressed)
                            .into(),
                    ]))
                    .add(settings::item_row(vec![
                        button(ButtonTheme::Primary).text("Primary").into(),
                        button(ButtonTheme::Secondary).text("Secondary").into(),
                        button(ButtonTheme::Positive).text("Positive").into(),
                        button(ButtonTheme::Destructive).text("Destructive").into(),
                        button(ButtonTheme::Text).text("Text").into(),
                    ]))
                    .into(),
                settings::view_section("Controls")
                    .add(settings::item(
                        "Toggler",
                        toggler(None, self.toggler_value, Message::TogglerToggled),
                    ))
                    .add(settings::item(
                        "Pick List (TODO)",
                        pick_list(
                            vec!["Option 1", "Option 2", "Option 3", "Option 4"],
                            self.pick_list_selected,
                            Message::PickListSelected,
                        ),
                    ))
                    .add(settings::item(
                        "Slider",
                        slider(0.0..=100.0, self.slider_value, Message::SliderChanged)
                            .width(Length::Fixed(250.0)),
                    ))
                    .add(settings::item(
                        "Progress",
                        progress_bar(0.0..=100.0, self.slider_value)
                            .width(Length::Fixed(250.0))
                            .height(Length::Fixed(4.0)),
                    ))
                    .into(),
            ])
            .into();

            let mut widgets: Vec<Element<_>> = Vec::with_capacity(2);

            widgets.push(
                scrollable(row![
                    horizontal_space(Length::Fill),
                    content.debug(self.debug),
                    horizontal_space(Length::Fill),
                ])
                .into(),
            );
        }

        let content = container(row(widgets))
            .padding([0, 8, 8, 8])
            .width(Length::Fill)
            .height(Length::Fill)
            .into();

        column(vec![header, content]).into()
    }

    fn should_exit(&self) -> bool {
        self.exit
    }

    fn theme(&self) -> Theme {
        self.theme.clone()
    }

    fn close_requested(&self, id: window::Id) -> Self::Message {
        Message::Close
    }
    fn subscription(&self) -> iced::Subscription<Self::Message> {
        rectangle_tracker_subscription(0).map(|m| {
            if let Some((_, e)) = m {
                Message::Rectangle(e)
            } else {
                Message::Ignore
            }
        })
    }
}