mod net;
use db::initialize;
use iced::{application, widget::{self, button, column, markdown, row, text}, Settings, Theme};
use net::load_rss;
use rss::Channel;
mod ui;
mod html;
mod db;



/*pub fn main() -> iced::Result {
    db::initialize();
iced::application("Really Sweet Stuff",State::update,State::view)
    .theme(theme)
    .run()
}*/
pub fn main() -> iced::Result{
    db::initialize();
    //db::add_feed("https://gabe.rocks/rss");
    iced::run(Viewer::update,Viewer::view)
    
    }   

#[derive(Clone,Debug)]
struct Viewer {
    content: Vec<markdown::Item>
}
impl Default for Viewer{
    fn default() -> Self {
        Self { content: markdown::parse(&html::process(db::return_item())).collect(), 
        }
    }
    
}

#[derive(Clone,Debug)]
enum Changes{
    Nullchange(markdown::Url)
}

impl Viewer{
    fn update(&mut self, _mes: Changes) {

    }
    fn view(&self) -> iced::Element<'_, Changes> {
        widget::container(
        widget::scrollable(
        markdown::view(
            &self.content,
            markdown::Settings::with_style(markdown::Style::from_palette(iced::Theme::Dark.palette())),
            
        ).map(Changes::Nullchange))
        )
        .align_x(iced::alignment::Horizontal::Center)
        .align_y(iced::alignment::Vertical::Center)
        .width(iced::Length::Fill)
        .height(iced::Length::Fill)
        .padding(5)
        .into()


    }
}
#[derive(Clone,Debug)]
struct State {
    scene:  Scene,
    channels: Vec<Channel>,
    current_channel: usize,
    current_item: usize,
    item_open: bool,
    play_media: bool,
}

fn theme(state: &State) -> Theme {
    iced::Theme::Nord            
}

#[derive(Clone, Copy, Debug)]
pub enum Scene {
    Feeds,
    Items,
    ItemView,
}

impl Default for Scene {
    fn default() -> Self {
        Scene::Feeds
    }
}

#[derive(Debug, Clone)]
pub enum Message {
    SetScene(Scene),
    SetChannel(usize),
    SetItem(usize),
    OpenItem,
    ToggleMedia,
    AddFeed(String),
}

impl Default for State {
    fn default() -> Self {
        let main = net::load_rss("https://libresolutions.network/rss").unwrap();
        let small = net::load_rss("https://libresolutions.network/about/index.xml").unwrap();
        let gabefeed = net::load_rss("https://gabe.rocks/rss").unwrap();
        let channels = vec![small];
        Self {
            scene: Scene::ItemView,
            channels,
            current_channel: 0,
            current_item: 0,
            item_open: true,
            play_media: false,
        }
    }
}

impl State {

    fn update(&mut self, mes: Message) {
        match mes {
            Message::SetScene (scene) => self.scene = scene,
            Message::SetChannel(c) => {
                self.current_channel = c;
                self.scene = Scene::Items;
            },
            Message::SetItem(i) => {
                self.current_item = i;
                self.scene = Scene::ItemView;
            },
            Message::OpenItem => self.item_open = !self.item_open,
            Message::ToggleMedia => self.play_media = !self.play_media,
            Message::AddFeed(feed) => {self.channels.push(load_rss(&feed).unwrap())}
        }
    }

    fn view(&self) -> iced::Element<'_, Message> {
        match self.scene {
            Scene::Feeds => {
                ui::channel_view(&self.channels)
            },
            Scene::Items => {
                ui::item_list_view(&self.channels[self.current_channel])
            },
            Scene::ItemView => {
                let item = &self.channels[self.current_channel].items()[self.current_item];
                ui::item_view(item)
            }
        }.into()
    }
    
}