use cosmic::iced::wayland::SurfaceIdWrapper;
use cosmic::iced::widget;
use iced::widget::Space;

use cosmic::widget::{icon, toggler, horizontal_rule};
use cosmic::applet::CosmicAppletHelper;
use cosmic::Renderer;

use cosmic::iced_native::window::Settings;
use cosmic::iced_style::application::{self, Appearance};
use cosmic::iced_style::svg;
use cosmic::theme::{self, Svg};
use cosmic::{iced_style, settings, Element, Theme};
use cosmic::iced::{
    self,
    executor,
    widget::{button, column, row, text, slider},
    window, Alignment, Application, Command, Length, Subscription,
};


use iced::wayland::popup::{destroy_popup, get_popup};
use iced::Color;
use iced::widget::container;

mod pulse;
use crate::pulse::DeviceInfo;
use libpulse_binding::volume::{Volume, VolumeLinear};

pub fn main() -> cosmic::iced::Result {
    let helper = CosmicAppletHelper::default();
    Audio::run(helper.window_settings())
}

#[derive(Default)]
struct Audio {
    is_open: IsOpen,
    current_output: Option<DeviceInfo>,
    current_input: Option<DeviceInfo>,
    outputs: Vec<DeviceInfo>,
    inputs: Vec<DeviceInfo>,
    pulse_state: PulseState,
    applet_helper: CosmicAppletHelper,
    icon_name: String,
    theme: Theme,
    popup: Option<window::Id>,
    id_ctr: u32,
}

#[derive(Debug, PartialEq, Eq)]
enum IsOpen {
    None,
    Output,
    Input,
}

#[derive(Debug, Clone)]
enum Message {
    SetOutputVolume(f64),
    SetInputVolume(f64),
    OutputToggle,
    InputToggle,
    OutputChanged(String),
    InputChanged(String),
    Pulse(pulse::Event),
    Ignore,
    TogglePopup,
}

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

    fn new(_flags: ()) -> (Audio, Command<Message>) {
        (
            Audio {
                is_open: IsOpen::None,
                current_output: None,
                current_input: None,
                outputs: vec![],
                inputs: vec![],
                pulse_state: PulseState::Disconnected,
                icon_name: "audio-volume-high-symbolic".to_string(),
                ..Default::default()
            },
            Command::none(),
        )
    }

    fn title(&self) -> String {
        String::from("Audio")
    }

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

    fn close_requested(&self, _id: SurfaceIdWrapper) -> Self::Message {
        Message::Ignore
    }

    fn style(&self) -> <Self::Theme as application::StyleSheet>::Style {
        <Self::Theme as application::StyleSheet>::Style::Custom(|theme| Appearance {
            background_color: Color::from_rgba(0.0, 0.0, 0.0, 0.0),
            text_color: theme.cosmic().on_bg_color().into(),
        })
    }

    fn update(&mut self, message: Message) -> Command<Message> {
        match message {
            Message::TogglePopup => {
                if let Some(p) = self.popup.take() {
                    return destroy_popup(p);
                } else {
                    self.id_ctr += 1; 
                    let new_id = window::Id::new(self.id_ctr);
                    self.popup.replace(new_id);

                    let popup_settings =
                        self.applet_helper.get_popup_settings(window::Id::new(0), new_id, (400, 300), None, None);
                    return get_popup(popup_settings);
                }
            }
            Message::SetOutputVolume(vol) => {
                self.current_output.as_mut().map(|o| {
                    o.volume
                        .set(o.volume.len(), VolumeLinear(vol / 100.0).into())
                });
                if let PulseState::Connected(connection) = &mut self.pulse_state {
                    if let Some(device) = &self.current_output {
                        if let Some(name) = &device.name {
                            connection.send(pulse::Message::SetSinkVolumeByName(
                                name.clone().to_string(),
                                device.volume,
                            ))
                        }
                    }
                }
            }
            Message::SetInputVolume(vol) => {
                self.current_input.as_mut().map(|i| {
                    i.volume
                        .set(i.volume.len(), VolumeLinear(vol / 100.0).into())
                });
                if let PulseState::Connected(connection) = &mut self.pulse_state {
                    if let Some(device) = &self.current_input {
                        if let Some(name) = &device.name {
                            println!("increasing volume of {}", name);
                            connection.send(pulse::Message::SetSourceVolumeByName(
                                name.clone().to_string(),
                                device.volume,
                            ))
                        }
                    }
                }
            }
            Message::OutputChanged(val) => println!("changed output {}", val),
            Message::InputChanged(val) => println!("changed input {}", val),
            Message::OutputToggle => {
                self.is_open = if self.is_open == IsOpen::Output {
                    IsOpen::None
                } else {
                    IsOpen::Output
                }
            }
            Message::InputToggle => {
                self.is_open = if self.is_open == IsOpen::Input {
                    IsOpen::None
                } else {
                    IsOpen::Input
                }
            }
            Message::Pulse(event) => match event {
                pulse::Event::Connected(mut connection) => {
                    connection.send(pulse::Message::GetSinks);
                    connection.send(pulse::Message::GetSources);
                    connection.send(pulse::Message::GetDefaultSink);
                    connection.send(pulse::Message::GetDefaultSource);
                    self.pulse_state = PulseState::Connected(connection);
                }
                pulse::Event::MessageReceived(msg) => {
                    match msg {
                        // This is where we match messages from the subscription to app state
                        pulse::Message::SetSinks(sinks) => self.outputs = sinks,
                        pulse::Message::SetSources(sources) => {
                            self.inputs = sources
                                .into_iter()
                                .filter(|source| {
                                    !source
                                        .name
                                        .as_ref()
                                        .unwrap_or(&String::from("Generic"))
                                        .contains("monitor")
                                })
                                .collect()
                        }
                        pulse::Message::SetDefaultSink(sink) => {
                            self.current_output = Some(sink);
                        }
                        pulse::Message::SetDefaultSource(source) => {
                            self.current_input = Some(source)
                        }
                        pulse::Message::Disconnected => {
                            panic!("Subscriton error handling is bad. This should never happen.")
                        }
                        _ => {
                            println!("Received misc message")
                        }
                    }
                }
                // TODO: view() should gray out buttons/slider when state is disconnected
                pulse::Event::Disconnected => {
                    println!("setting state to disconnected");
                    self.pulse_state = PulseState::Disconnected
                }
            },
            Message::Ignore => {},
        };

        Command::none()
    }

    fn subscription(&self) -> Subscription<Message> {
        pulse::connect().map(Message::Pulse)
    }

    fn view(&self, id: SurfaceIdWrapper) -> Element<Message> { 
        match id {
            SurfaceIdWrapper::LayerSurface(_) => unimplemented!(),
            SurfaceIdWrapper::Window(_) => self.applet_helper.icon_button(
                &self.icon_name,
            )
            .on_press(Message::TogglePopup)
            .into(),
            SurfaceIdWrapper::Popup(_) => {
                let out_f64 = VolumeLinear::from(
                    self.current_output
                        .as_ref()
                        .map(|o| o.volume.avg())
                        .unwrap_or(Volume::default()),
                )
                .0 * 100.0;
                let in_f64 = VolumeLinear::from(
                    self.current_input
                        .as_ref()
                        .map(|o| o.volume.avg())
                        .unwrap_or(Volume::default()),
                )
                .0 * 100.0;

                let sink = row![
                    icon("status/audio-volume-high-symbolic", 24),
                    slider(0.0..=100.0, out_f64, Message::SetOutputVolume),
                    text(format!("{}%", out_f64.round()))
                ]
                .spacing(10)
                .padding(10);
                let source = row![
                    icon("devices/audio-input-microphone-symbolic", 24),
                    slider(0.0..=100.0, in_f64, Message::SetInputVolume),
                    text(format!("{}%", in_f64.round()))
                ]
                .spacing(10)
                .padding(10);

                // TODO change these from helper functions to iced components for improved reusability
                let output_drop = revealer(
                    self.is_open == IsOpen::Output,
                    "Output",
                    match &self.current_output {
                        Some(output) => pretty_name(output.description.clone()),
                        None => String::from("No device selected"),
                    },
                    self.outputs
                        .clone()
                        .into_iter()
                        .map(|output| pretty_name(output.description))
                        .collect(),
                    Message::OutputToggle,
                    Message::OutputChanged(String::from("test")),
                );
                let input_drop = revealer(
                    self.is_open == IsOpen::Input,
                    "Input",
                    match &self.current_input {
                        Some(input) => pretty_name(input.description.clone()),
                        None => String::from("No device selected"),
                    },
                    self.inputs
                        .clone()
                        .into_iter()
                        .map(|input| pretty_name(input.description))
                        .collect(),
                    Message::InputToggle,
                    Message::InputChanged(String::from("test")),
                );

                let content = column![]
                    .align_items(Alignment::Start)
                    .spacing(20)
                    .push(sink)
                    .push(source)
                    .push(spacer())
                    .push(output_drop)
                    .push(input_drop);

                self.applet_helper.popup_container(
                    container(content)
                    ).into()
            }
        }
    }
}

// TODO: Make this a themeable widget like the mock-ups
fn spacer() -> iced::widget::Space {
    Space::with_width(Length::Fill)
}

fn revealer<'a>(
    open: bool,
    title: &'a str,
    selected: String,
    options: Vec<String>,
    toggle: Message,
    _change: Message,
) -> widget::Column<'a, Message, Renderer> {
    if open {
        options.iter().fold(
            column![revealer_head(open, title, selected, toggle)].width(Length::Fill),
            |col, device| col.push(text(device)),
        )
    } else {
        column![revealer_head(open, title, selected, toggle)]
    }
}

fn revealer_head<'a>(
    _open: bool,
    title: &'a str,
    selected: String,
    toggle: Message,
) -> widget::Button<Message, Renderer> {
    button(row![row![title].width(Length::Fill), text(selected)])
        .width(Length::Fill)
        .on_press(toggle)
}

fn pretty_name(name: Option<String>) -> String {
    match name {
        Some(n) => n,
        None => String::from("Generic"),
    }
}

enum PulseState {
    Disconnected,
    Connected(pulse::Connection),
}

impl Default for PulseState {
    fn default() -> Self {
        Self::Disconnected
    }
}

impl Default for IsOpen {
    fn default() -> Self {
        IsOpen::None
    }
}