use crate::*;
use iced::Element;

pub fn settings(state: &State) -> Element<'_, Message> {
    screens::settings(state)
}

pub fn update(state: &mut State, message: SettingsMessage) -> Task<Message> {
    match message {
        SettingsMessage::Open => {
            tracing::trace!("Opening settings");
            state.screen = Screen::Settings;
        }
        SettingsMessage::Close => {
            tracing::trace!("Closing settings");
            state.screen = Screen::Home;
        }
        SettingsMessage::Select(screen) => {
            tracing::trace!("Switching settings screen to {:?}", screen);
            state.settings.screen = screen;
        } //
          // SettingsMessage::User(user) => state.settings.login_form.update(user),
          //
          // SettingsMessage::Server(server) => state.settings.server_page.update(server),
    }
    Task::none()
}

pub fn empty() -> Element<'static, Message> {
    column([]).into()
}

#[derive(Debug, Clone)]
pub enum SettingsMessage {
    Open,
    Close,
    Select(SettingsScreen),
    // User(UserMessage),
    // Server(ServerMessage),
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub enum SettingsScreen {
    #[default]
    Main,
    Users,
    Servers,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SettingsState {
    pub screen: SettingsScreen,
}

mod screens {
    use iced_aw::Tabs;

    use super::*;
    pub fn settings(state: &State) -> Element<'_, Message> {
        Tabs::new(|f| Message::Settings(SettingsMessage::Select(f)))
            .push(
                SettingsScreen::Main,
                iced_aw::TabLabel::Text("General".into()),
                main(state),
            )
            .push(
                SettingsScreen::Servers,
                iced_aw::TabLabel::Text("Servers".into()),
                server(state),
            )
            .push(
                SettingsScreen::Users,
                iced_aw::TabLabel::Text("Users".into()),
                user(state),
            )
            .set_active_tab(&state.settings.screen)
            .into()
    }

    pub fn settings_screen(state: &State) -> Element<'_, Message> {
        container(match state.settings.screen {
            SettingsScreen::Main => main(state),
            SettingsScreen::Servers => server(state),
            SettingsScreen::Users => user(state),
        })
        .width(Length::FillPortion(10))
        .height(Length::Fill)
        .style(|theme| container::background(theme.extended_palette().background.base.color))
        .pipe(container)
        .padding(10)
        .style(|theme| container::background(theme.extended_palette().secondary.base.color))
        .width(Length::FillPortion(10))
        .into()
    }

    pub fn settings_list(state: &State) -> Element<'_, Message> {
        column(
            [
                button(center_text("General")).on_press(Message::Settings(
                    SettingsMessage::Select(SettingsScreen::Main),
                )),
                button(center_text("Servers")).on_press(Message::Settings(
                    SettingsMessage::Select(SettingsScreen::Servers),
                )),
                button(center_text("Users")).on_press(Message::Settings(SettingsMessage::Select(
                    SettingsScreen::Users,
                ))),
            ]
            .map(|p| p.clip(true).width(Length::Fill).into()),
        )
        .width(Length::FillPortion(2))
        .spacing(10)
        .padding(10)
        .pipe(scrollable)
        .into()
    }

    pub fn main(state: &State) -> Element<'_, Message> {
        Column::new()
            .push(text("Main Settings"))
            .push(toggler(true).label("HDR"))
            .push(toggler(true).label("Enable Notifications"))
            .spacing(20)
            .padding(20)
            .pipe(container)
            .into()
    }

    pub fn server(state: &State) -> Element<'_, Message> {
        Column::new()
            .push(text("Server Settings"))
            // .push(ServerPage::view(state))
            .spacing(20)
            .padding(20)
            .pipe(container)
            .into()
    }

    pub fn user(state: &State) -> Element<'_, Message> {
        Column::new()
            .push(text("User Settings"))
            // .push(LoginForm::view(&state.settings.login_form))
            .spacing(20)
            .padding(20)
            .pipe(container)
            .into()
    }
}

pub fn center_text(content: &str) -> Element<'_, Message> {
    text(content)
        .align_x(Alignment::Center)
        .width(Length::Fill)
        .into()
}