use std::{any::type_name, ops::Deref, pin::Pin, str::FromStr};

use anyhow::Error;
use futures_util::{future::BoxFuture, Future, FutureExt};
use jsonwebtoken::{decode, Algorithm, DecodingKey, TokenData, Validation};
use rsa::{pkcs1::DecodeRsaPublicKey, RsaPublicKey};
use serde::{de::DeserializeOwned, Deserialize, Serialize};

use crate::{
    authentication::UserTokenMetadata, connection::wrapper::ConnectionState, messages::MessageKind,
};

use super::{instance::Instance, user::User};

#[derive(Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub struct Authenticated<T: Serialize> {
    #[serde(flatten)]
    source: Vec<AuthenticationSource>,
    message_type: String,
    #[serde(flatten)]
    message: T,
}

pub trait AuthenticationSourceProvider: Sized {
    fn authenticate(self, payload: &Vec<u8>) -> AuthenticationSource;
}

pub trait AuthenticationSourceProviders: Sized {
    fn authenticate_all(self, payload: &Vec<u8>) -> Vec<AuthenticationSource>;
}

impl<A> AuthenticationSourceProviders for A
where
    A: AuthenticationSourceProvider,
{
    fn authenticate_all(self, payload: &Vec<u8>) -> Vec<AuthenticationSource> {
        vec![self.authenticate(payload)]
    }
}

impl<A, B> AuthenticationSourceProviders for (A, B)
where
    A: AuthenticationSourceProvider,
    B: AuthenticationSourceProvider,
{
    fn authenticate_all(self, payload: &Vec<u8>) -> Vec<AuthenticationSource> {
        let (first, second) = self;

        vec![first.authenticate(payload), second.authenticate(payload)]
    }
}

impl<T: Serialize> Authenticated<T> {
    pub fn new(message: T, auth_sources: impl AuthenticationSourceProvider) -> Self {
        let message_payload = serde_json::to_vec(&message).unwrap();

        let authentication = auth_sources.authenticate_all(&message_payload);

        Self {
            source: authentication,
            message_type: type_name::<T>().to_string(),
            message,
        }
    }
}

mod verified {}

pub struct UserAuthenticator {
    pub user: User,
    pub token: UserAuthenticationToken,
}

impl AuthenticationSourceProvider for UserAuthenticator {
    fn authenticate(self, payload: &Vec<u8>) -> AuthenticationSource {
        AuthenticationSource::User {
            user: self.user,
            token: self.token,
        }
    }
}

pub struct InstanceAuthenticator<'a> {
    pub instance: Instance,
    pub private_key: &'a str,
}

impl AuthenticationSourceProvider for InstanceAuthenticator<'_> {
    fn authenticate(self, payload: &Vec<u8>) -> AuthenticationSource {
        todo!()
    }
}

#[repr(transparent)]
#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub struct UserAuthenticationToken(String);

impl From<String> for UserAuthenticationToken {
    fn from(value: String) -> Self {
        Self(value)
    }
}

impl ToString for UserAuthenticationToken {
    fn to_string(&self) -> String {
        self.0.clone()
    }
}

impl AsRef<str> for UserAuthenticationToken {
    fn as_ref(&self) -> &str {
        &self.0
    }
}

#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub struct InstanceSignature(Vec<u8>);

#[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
pub enum AuthenticationSource {
    User {
        user: User,
        token: UserAuthenticationToken,
    },
    Instance {
        instance: Instance,
        signature: InstanceSignature,
    },
}

pub struct NetworkMessage(pub Vec<u8>);

impl Deref for NetworkMessage {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub struct AuthenticatedUser(pub User);

#[derive(Debug, thiserror::Error)]
pub enum UserAuthenticationError {
    #[error("user authentication missing")]
    Missing,
    // #[error("{0}")]
    // InstanceAuthentication(#[from] Error),
    #[error("user token was invalid")]
    InvalidToken,
    #[error("an error has occured")]
    Other(#[from] Error),
}

pub struct AuthenticatedInstance(Instance);

impl AuthenticatedInstance {
    pub fn inner(&self) -> &Instance {
        &self.0
    }
}

#[async_trait::async_trait]
pub trait FromMessage<S: Send + Sync>: Sized + Send + Sync {
    async fn from_message(message: &NetworkMessage, state: &S) -> Result<Self, Error>;
}

#[async_trait::async_trait]
impl FromMessage<ConnectionState> for AuthenticatedUser {
    async fn from_message(
        network_message: &NetworkMessage,
        state: &ConnectionState,
    ) -> Result<Self, Error> {
        let message: Authenticated<MessageKind> =
            serde_json::from_slice(&network_message).map_err(|e| Error::from(e))?;

        let (auth_user, auth_token) = message
            .source
            .iter()
            .filter_map(|auth| {
                if let AuthenticationSource::User { user, token } = auth {
                    Some((user, token))
                } else {
                    None
                }
            })
            .next()
            .ok_or_else(|| UserAuthenticationError::Missing)?;

        let authenticated_instance =
            AuthenticatedInstance::from_message(network_message, state).await?;

        let public_key_raw = public_key(&auth_user.instance).await?;
        let verification_key = DecodingKey::from_rsa_pem(public_key_raw.as_bytes()).unwrap();

        let data: TokenData<UserTokenMetadata> = decode(
            auth_token.as_ref(),
            &verification_key,
            &Validation::new(Algorithm::RS256),
        )
        .unwrap();

        if data.claims.user != *auth_user
            || data.claims.generated_for != *authenticated_instance.inner()
        {
            Err(Error::from(UserAuthenticationError::InvalidToken))
        } else {
            Ok(AuthenticatedUser(data.claims.user))
        }
    }
}

#[async_trait::async_trait]
impl FromMessage<ConnectionState> for AuthenticatedInstance {
    async fn from_message(
        message: &NetworkMessage,
        state: &ConnectionState,
    ) -> Result<Self, Error> {
        todo!()
    }
}

#[async_trait::async_trait]
impl FromMessage<ConnectionState> for MessageKind {
    async fn from_message(
        message: &NetworkMessage,
        state: &ConnectionState,
    ) -> Result<Self, Error> {
        todo!()
    }
}

#[async_trait::async_trait]
impl<S, T> FromMessage<S> for Option<T>
where
    T: FromMessage<S>,
    S: Send + Sync + 'static,
{
    async fn from_message(message: &NetworkMessage, state: &S) -> Result<Self, Error> {
        Ok(T::from_message(message, state).await.ok())
    }
}

#[async_trait::async_trait]
pub trait MessageHandler<T, S, R> {
    async fn handle_message(self, message: &NetworkMessage, state: &S) -> Result<R, Error>;
}
#[async_trait::async_trait]
impl<F, R, S, T1, T, E> MessageHandler<(T1,), S, R> for T
where
    T: FnOnce(T1) -> F + Clone + Send + 'static,
    F: Future<Output = Result<R, E>> + Send,
    T1: FromMessage<S> + Send,
    S: Send + Sync,
    E: std::error::Error + Send + Sync + 'static,
{
    async fn handle_message(self, message: &NetworkMessage, state: &S) -> Result<R, Error> {
        let value = T1::from_message(message, state).await?;
        self(value).await.map_err(|e| Error::from(e))
    }
}

#[async_trait::async_trait]
impl<F, R, S, T1, T2, T, E> MessageHandler<(T1, T2), S, R> for T
where
    T: FnOnce(T1, T2) -> F + Clone + Send + 'static,
    F: Future<Output = Result<R, E>> + Send,
    T1: FromMessage<S> + Send,
    T2: FromMessage<S> + Send,
    S: Send + Sync,
    E: std::error::Error + Send + Sync + 'static,
{
    async fn handle_message(self, message: &NetworkMessage, state: &S) -> Result<R, Error> {
        let value = T1::from_message(message, state).await?;
        let value_2 = T2::from_message(message, state).await?;
        self(value, value_2).await.map_err(|e| Error::from(e))
    }
}

#[async_trait::async_trait]
impl<F, R, S, T1, T2, T3, T, E> MessageHandler<(T1, T2, T3), S, R> for T
where
    T: FnOnce(T1, T2, T3) -> F + Clone + Send + 'static,
    F: Future<Output = Result<R, E>> + Send,
    T1: FromMessage<S> + Send,
    T2: FromMessage<S> + Send,
    T3: FromMessage<S> + Send,
    S: Send + Sync,
    E: std::error::Error + Send + Sync + 'static,
{
    async fn handle_message(self, message: &NetworkMessage, state: &S) -> Result<R, Error> {
        let value = T1::from_message(message, state).await?;
        let value_2 = T2::from_message(message, state).await?;
        let value_3 = T3::from_message(message, state).await?;

        self(value, value_2, value_3)
            .await
            .map_err(|e| Error::from(e))
    }
}

pub struct State<T>(pub T);

#[async_trait::async_trait]
impl<T> FromMessage<T> for State<T>
where
    T: Clone + Send + Sync,
{
    async fn from_message(_: &NetworkMessage, state: &T) -> Result<Self, Error> {
        Ok(Self(state.clone()))
    }
}

// Temp
#[async_trait::async_trait]
impl<T, S> FromMessage<S> for Message<T>
where
    T: DeserializeOwned + Send + Sync + Serialize,
    S: Clone + Send + Sync,
{
    async fn from_message(message: &NetworkMessage, _: &S) -> Result<Self, Error> {
        Ok(Message(serde_json::from_slice(&message)?))
    }
}

pub struct Message<T: Serialize + DeserializeOwned>(pub T);

async fn public_key(instance: &Instance) -> Result<String, Error> {
    let key = reqwest::get(format!("https://{}/.giterated/pubkey.pem", instance.url))
        .await?
        .text()
        .await?;

    Ok(key)
}