use std::{
    net::SocketAddr,
    sync::{atomic::AtomicBool, Arc},
};

use anyhow::Error;
use futures_util::SinkExt;
use serde::Serialize;
use tokio::{net::TcpStream, sync::Mutex};
use tokio_tungstenite::{tungstenite::Message, WebSocketStream};

use crate::{
    authentication::AuthenticationTokenGranter,
    backend::{DiscoveryBackend, RepositoryBackend, UserBackend},
    connection::ConnectionError,
    listener::Listeners,
    model::instance::Instance,
};

use super::{connection_worker, Connections};

pub async fn connection_wrapper(
    mut socket: WebSocketStream<TcpStream>,
    listeners: Arc<Mutex<Listeners>>,
    connections: Arc<Mutex<Connections>>,
    repository_backend: Arc<Mutex<dyn RepositoryBackend + Send>>,
    user_backend: Arc<Mutex<dyn UserBackend + Send>>,
    auth_granter: Arc<Mutex<AuthenticationTokenGranter>>,
    discovery_backend: Arc<Mutex<dyn DiscoveryBackend + Send>>,
    addr: SocketAddr,
) {
    let mut handshaked = false;
    loop {
        if let Err(e) = connection_worker(
            &mut socket,
            &mut handshaked,
            &listeners,
            &connections,
            &repository_backend,
            &user_backend,
            &auth_granter,
            &discovery_backend,
            &addr,
        )
        .await
        {
            error!("Error handling message: {:?}", e);

            if let ConnectionError::Shutdown = &e {
                info!("Closing connection {}", addr);
                return;
            }
        }
    }
}

#[derive(Clone)]
pub struct ConnectionState {
    socket: Arc<Mutex<WebSocketStream<TcpStream>>>,
    pub listeners: Arc<Mutex<Listeners>>,
    pub connections: Arc<Mutex<Connections>>,
    pub repository_backend: Arc<Mutex<dyn RepositoryBackend + Send>>,
    pub user_backend: Arc<Mutex<dyn UserBackend + Send>>,
    pub auth_granter: Arc<Mutex<AuthenticationTokenGranter>>,
    pub discovery_backend: Arc<Mutex<dyn DiscoveryBackend + Send>>,
    pub addr: SocketAddr,
    pub instance: Instance,
    pub handshaked: Arc<AtomicBool>,
}

impl ConnectionState {
    pub async fn send<T: Serialize>(&self, message: T) -> Result<(), Error> {
        self.socket
            .lock()
            .await
            .send(Message::Binary(serde_json::to_vec(&message)?))
            .await?;

        Ok(())
    }
}