use gloo_net::http::Request;
use gloo_net::Error;
use patternfly_yew::ToastViewer;
use yew::prelude::*;

use crate::components::{Group, Home, TestMessage, ToastFields, ToastType};

pub struct ListGroups {
    idUser: String,
    groups: Vec<Group>,
    nb_show: usize,
}

#[derive(PartialEq, Properties)]
pub struct PropGroups {
    pub id: String,
}

#[derive(PartialEq)]
pub enum MsgListGroups {
    Done(Vec<Group>),
    Info(String, String),
    Error(String, String),
    More,
}

impl Component for ListGroups {
    type Message = MsgListGroups;
    type Properties = PropGroups;

    fn create(ctx: &Context<Self>) -> Self {
        Self {
            idUser: ctx.props().id.clone(),
            groups: Vec::new(),
            nb_show: 0,
        }
    }

    fn view(&self, ctx: &Context<Self>) -> Html {
        if self.groups.len() == 0 {
            let id = self.idUser.clone();
            ctx.link().send_future(async move {
                match Request::get(&format!("/api/users/{}/groups", id))
                    .send()
                    .await
                {
                    Ok(resp) => {
                        if resp.ok() {
                            let json: Result<Vec<Group>, Error> = resp.json().await;
                            match json {
                                Ok(mut json) => {
                                    for item in json.iter_mut() {
                                        item.get_game_name().await;
                                    }
                                    return MsgListGroups::Done(json);
                                }
                                Err(err) => {
                                    log::info!("{}", err.to_string());
                                    ()
                                }
                            }
                        }
                    }
                    Err(_) => (),
                };
                MsgListGroups::Info(String::from("Ok"), String::new())
            });
        }

        let onclick = ctx.link().callback(|_| MsgListGroups::More);

        html! {
            <>
            <ToastViewer />
            if self.groups.len() > 0 {
                {
                    self.groups[..self.nb_show].iter().map(|group| { html!{
                        <p>{ group.name.clone() }</p>
                    } }).collect::<Html>()
                }

                if self.nb_show < self.groups.len() {
                    <button onclick={onclick}>{ "Plus de groupes" }</button>
                }
            } else {
                <p>{ "Vous n'ĂȘtes dans aucun groupe." }</p>
            }
            //<p>{ "coucou" }</p>
            </>
        }
    }

    fn update(&mut self, ctx: &Context<Self>, msg: Self::Message) -> bool {
        match msg {
            MsgListGroups::Info(title, body) => {
                if let Some(parent) = ctx.link().get_parent() {
                    (parent.clone())
                        .downcast::<Home>()
                        .send_message(TestMessage::Toast(ToastType::Info(ToastFields {
                            title,
                            body,
                        })))
                }
            }
            MsgListGroups::Error(title, body) => {
                if let Some(parent) = ctx.link().get_parent() {
                    (parent.clone())
                        .downcast::<Home>()
                        .send_message(TestMessage::Toast(ToastType::Error(ToastFields {
                            title,
                            body,
                        })))
                }
            }
            MsgListGroups::Done(groups) => {
                let len = groups.len();
                self.groups = groups;
                self.nb_show = if len < 3 {
                    len
                } else {
                    3
                };

                return true;
            }
            MsgListGroups::More => {
                self.nb_show += 3;
                if self.nb_show > self.groups.len() {
                    self.nb_show -= self.nb_show - self.groups.len();
                }
                return true;
            }
        }
        false
    }
}