use std::rc::Rc;

use dioxus::prelude::*;
use futures_util::stream::StreamExt;
use tracing::{debug, error, warn};

use crate::domain::model::account::Account;
use crate::domain::model::messaging_interface::AccountMessagingProviderInterface;
use crate::domain::model::session::Session;
use crate::infrastructure::messaging::matrix::client::Client;
use crate::infrastructure::messaging::matrix::worker_tasks::LoginStyle;
use crate::ui::store::Store;

pub async fn login(mut rx: UnboundedReceiver<bool>, session: &GlobalSignal<Session>) {
    while let Some(is_logged) = rx.next().await {
        error!("is_logged={is_logged}");
        if !is_logged {
            let homeserver_url = session.read().homeserver_url.clone();
            let username = session.read().username.clone();
            let password = session.read().password.clone();

            if homeserver_url.is_some() && username.is_some() && password.is_some() {
                let (requester, account_events_receiver) =
                    Client::spawn(homeserver_url.unwrap()).await;

                if let Err(err) = requester.init().await {
                    error!("Following error occureds during client init: {}", err);
                }

                error!("Before login");

                match requester
                    .login(LoginStyle::Password(username.unwrap(), password.unwrap()))
                    .await
                {
                    Ok(_) => {
                        debug!("successfully logged");
                        session.write().is_logged = true;

                        let requester = Rc::new(requester);

                        dioxus::prelude::spawn(async move {
                            // ACCOUNT.write().set_messaging_provider(requester.clone());
                            ACCOUNT.write().set_messaging_provider(requester.clone());

                            let _ = requester
                                .run_forever(&*ACCOUNT.read(), account_events_receiver)
                                .await;
                        });
                    }
                    Err(err) => {
                        error!("Error during login: {err}");
                        // TODO: Handle invalid login
                        // invalid_login.modify(|_| true);
                        return;
                    }
                }
            } else {
                warn!("At least one of the following values is/are invalid: homeserver, username or password");
            }
        } else {
            warn!("already logged... skip login");
        }
    }
    error!("=== LOGIN END ===");
}

pub static STORE: GlobalSignal<Store> = Signal::global(Store::new);

// TODO: Merge ACCOUNT and SESSION
pub static ACCOUNT: GlobalSignal<Account> = Signal::global(|| Account::new(&STORE));
pub static SESSION: GlobalSignal<Session> = Signal::global(Session::new);