macltok

use std::{

    collections::{HashMap, VecDeque},

    sync::{

        Arc,

        atomic::{AtomicBool, Ordering},

    },

    time::Duration,

};

use futures_util::{FutureExt, future::WeakShared};

use matrix_sdk::{

    Client, HttpError,

    ruma::api::{

        Metadata,

        client::{authenticated_media, media},

    },

};

use ruma::{

    api::error::ErrorKind as ApiErrorKind,

    serde::{JsonObject, Raw},

    time::Instant,

};

use tokio::sync::Mutex;

use super::executor::EngineBoxFuture;

use crate::{Error, LinkPreview, normalise::server_preview};

const HIT_FOR: Duration = Duration::from_secs(60 * 60);

const MISS_FOR: Duration = Duration::from_secs(10 * 60);

const REMEMBERED: usize = 512;

type Lookup = EngineBoxFuture<'static, Result<Option<LinkPreview>, Error>>;

/// the homeserver rate limits `preview_url` and a busy timeline repeats links, so answers are

/// kept a while, misses too, and asks for one url at once share one request

pub(crate) struct UrlPreviews(Arc<Inner>);

struct Inner {

    client: Client,

    /// a server that doesn't preview at all says so once and isn't asked again

    unsupported: AtomicBool,

    cache: Mutex<Cache>,

    lookups: Mutex<HashMap<String, WeakShared<Lookup>>>,

}

#[derive(Default)]

struct Cache {

    entries: HashMap<String, (Instant, Option<LinkPreview>)>,

    order: VecDeque<String>,

}

impl UrlPreviews {

    pub(crate) fn new(client: Client) -> Self {

        Self(Arc::new(Inner {

            client,

            unsupported: AtomicBool::new(false),

            cache: Mutex::new(Cache::default()),

            lookups: Mutex::new(HashMap::new()),

        }))

    }

    pub(crate) async fn preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {

        if self.0.unsupported.load(Ordering::Relaxed) {

            return Ok(None);

        }

        if let Some(preview) = self.0.cache.lock().await.get(url) {

            return Ok(preview);

        }

        let lookup = {

            let mut lookups = self.0.lookups.lock().await;

            lookups.retain(|_, lookup| lookup.upgrade().is_some());

            match lookups.get(url).and_then(WeakShared::upgrade) {

                Some(lookup) => lookup,

                None => {

                    let inner = self.0.clone();

                    let owned = url.to_owned();

                    let lookup: Lookup = Box::pin(async move { inner.look_up(owned).await });

                    let lookup = lookup.shared();

                    if let Some(weak) = lookup.downgrade() {

                        lookups.insert(url.to_owned(), weak);

                    }

                    lookup

                }

            }

        };

        lookup.await

    }

}

impl Inner {

    async fn look_up(&self, url: String) -> Result<Option<LinkPreview>, Error> {

        let data = match self.fetch(&url).await {

            Ok(data) => data,

            Err(error) => {

                let Some(api) = error.as_client_api_error() else {

                    return Err(Error::from_sdk(

                        "asking for a url preview failed",

                        error.into(),

                    ));

                };

                let unrecognised = matches!(api.error_kind(), Some(ApiErrorKind::Unrecognized))

                    || api.status_code.as_u16() == 405;

                if unrecognised {

                    self.unsupported.store(true, Ordering::Relaxed);

                    return Ok(None);

                }

                // synapse answers 500 for a page it can't download, 502 when dns fails and 403 for

                // its blocklist (synapse/media/url_previewer.py). a real fault hides in the 500s too,

                // but a missing card is cheap and only cached ten minutes

                if !matches!(api.status_code.as_u16(), 400 | 403 | 404 | 500 | 502) {

                    return Err(Error::from_sdk(

                        "asking for a url preview failed",

                        error.into(),

                    ));

                }

                None

            }

        };

        let preview = data.and_then(|data| server_preview(&url, &data));

        self.cache.lock().await.insert(url, preview.clone());

        Ok(preview)

    }

    async fn fetch(&self, url: &str) -> Result<Option<Raw<JsonObject>>, HttpError> {

        let versions = self.client.supported_versions().await?;

        let data = if authenticated_media::get_media_preview::v1::Request::PATH_BUILDER

            .is_supported(&versions)

        {

            self.client

                .send(authenticated_media::get_media_preview::v1::Request::new(

                    url.to_owned(),

                ))

                .await?

                .data

        } else {

            #[allow(deprecated)]

            let request = media::get_media_preview::v3::Request::new(url.to_owned());

            self.client.send(request).await?.data

        };

        Ok(data.map(Raw::from_json))

    }

}

impl Cache {

    fn get(&mut self, url: &str) -> Option<Option<LinkPreview>> {

        let (at, preview) = self.entries.get(url)?;

        let lasts = if preview.is_some() { HIT_FOR } else { MISS_FOR };

        (at.elapsed() < lasts).then(|| preview.clone())

    }

    fn insert(&mut self, url: String, preview: Option<LinkPreview>) {

        if self

            .entries

            .insert(url.clone(), (Instant::now(), preview))

            .is_none()

        {

            self.order.push_back(url);

        }

        while self.entries.len() > REMEMBERED {

            let Some(oldest) = self.order.pop_front() else {

                break;

            };

            self.entries.remove(&oldest);

        }

    }

}