use std::collections::{HashMap, HashSet};

use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Subscription, Task};
use instant::Duration;
use nostr_sdk::prelude::*;
use smallvec::{SmallVec, smallvec};
use state::NostrRegistry;

/// Disable scoring when the follow set exceeds this size
const MAX_FOLLOWS: usize = 2000;
/// Cap a followed author's contact list to bound hostile publishers
const MAX_TAGS_PER_LIST: usize = 5000;
/// Time between reconciliations with the relays
const SYNC_INTERVAL: u64 = 15 * 60;

struct GlobalWebOfTrust(Entity<WebOfTrust>);

impl Global for GlobalWebOfTrust {}

/// A change to the web of trust
#[derive(Debug, Clone)]
pub enum WoTEvent {
    /// The graph changed
    Updated,
    /// The initial load finished
    Ready,
}

impl EventEmitter<WoTEvent> for WebOfTrust {}

/// Web of trust
///
/// Scores public keys by how many of the current user's contacts follow them,
/// built from the contact lists (NIP-02) of the people the user follows.
#[derive(Debug)]
pub struct WebOfTrust {
    /// Current user's public key
    self_key: Option<PublicKey>,
    /// Latest known contact list of the current user
    follows: HashSet<PublicKey>,
    /// Created at of the latest contact list of the current user
    follows_at: Option<Timestamp>,
    /// Latest known contact list per followed author, with its created at
    lists: HashMap<PublicKey, (Timestamp, HashSet<PublicKey>)>,
    /// Reverse index: target -> contacts who follow them
    reverse: HashMap<PublicKey, HashSet<PublicKey>>,
    /// Whether scoring is disabled due to an oversized follow set
    disabled: bool,
    /// Whether the initial load has finished
    ready: bool,
    /// Whether the next refresh completes the initial load
    initial: bool,
    /// Task loading the graph, replaced by newer loads
    hydration: Option<Task<()>>,
    /// Tasks for asynchronous operations
    tasks: SmallVec<[Task<()>; 4]>,
    /// Event subscriptions
    _subscriptions: SmallVec<[Subscription; 1]>,
}

impl WebOfTrust {
    /// Retrieve the global web of trust
    pub fn global(cx: &App) -> Entity<Self> {
        cx.global::<GlobalWebOfTrust>().0.clone()
    }

    /// Set the global web of trust instance
    pub(crate) fn set_global(state: Entity<Self>, cx: &mut App) {
        cx.set_global(GlobalWebOfTrust(state));
    }

    /// Create a new web of trust instance
    pub(crate) fn new(cx: &mut Context<Self>) -> Self {
        let nostr = NostrRegistry::global(cx);
        let entity = cx.entity().downgrade();

        let mut tasks = smallvec![];

        tasks.push(cx.spawn(async move |this, cx| {
            loop {
                cx.background_executor()
                    .timer(Duration::from_secs(SYNC_INTERVAL))
                    .await;
                // Ignore errors, the next refresh will retry
                let _ = this.update(cx, |this, cx| {
                    this.sync(cx);
                });
            }
        }));

        let subscription = cx.subscribe(&nostr, |this, _nostr, event, cx| {
            if event.signer_changed() {
                this.reset(cx);
                this.hydrate(cx);
            }
        });

        cx.defer(move |cx| {
            let _ = entity.update(cx, |this, cx| {
                this.hydrate(cx);
            });
        });

        Self {
            self_key: None,
            follows: HashSet::new(),
            follows_at: None,
            lists: HashMap::new(),
            reverse: HashMap::new(),
            disabled: false,
            ready: false,
            initial: false,
            hydration: None,
            tasks,
            _subscriptions: smallvec![subscription],
        }
    }

    /// Load the graph for the current account
    fn hydrate(&mut self, cx: &mut Context<Self>) {
        let nostr = NostrRegistry::global(cx);
        let client = nostr.read(cx).client();
        let Some(self_key) = nostr.read(cx).current_user() else {
            return;
        };

        self.self_key = Some(self_key);
        self.initial = true;

        // The locally stored contact list, applied before the relays respond
        let local: Task<Option<Event>> = cx.background_spawn(async move {
            let filter = Filter::new()
                .author(self_key)
                .kind(Kind::ContactList)
                .limit(1);

            client
                .database()
                .query(filter)
                .await
                .unwrap_or_default()
                .into_iter()
                .next()
        });

        self.hydration = Some(cx.spawn(async move |this, cx| {
            let latest = local.await;
            let at = latest.as_ref().map(|event| event.created_at);

            let snapshot: HashSet<PublicKey> = latest
                .as_ref()
                .map(|event| event.tags.public_keys().take(MAX_FOLLOWS + 1).collect())
                .unwrap_or_default();

            // Credit the local graph before the relays respond
            this.update(cx, |this, cx| {
                if this.self_key == Some(self_key) && this.store_follows(at, snapshot.clone()) {
                    cx.emit(WoTEvent::Updated);
                    cx.notify();
                }
            })
            .ok();

            // Reconcile with the relays; the refresh this triggers finalizes the initial load
            this.update(cx, |this, cx| {
                this.sync(cx);
            })
            .ok();
        }));
    }

    /// Reconcile the follow set's contact lists with the relays and apply whatever came back
    fn sync(&mut self, cx: &mut Context<Self>) {
        let nostr = NostrRegistry::global(cx);
        let client = nostr.read(cx).client();

        let Some(self_key) = nostr.read(cx).current_user() else {
            return;
        };

        let covered: HashSet<PublicKey> = self.follows.clone();

        let mut authors: Vec<PublicKey> = covered.iter().copied().collect();
        authors.push(self_key);

        self.tasks.push(cx.spawn(async move |this, cx| {
            let filter = Filter::new().kind(Kind::ContactList).authors(authors);

            // Negentropy transfers only the lists the relays hold and the database is missing
            if let Err(error) = client.sync(filter).await {
                log::warn!("Failed to reconcile contact lists: {error}");
            }

            let mut authors: Vec<PublicKey> = covered.iter().copied().collect();
            authors.push(self_key);

            let filter = Filter::new().kind(Kind::ContactList).authors(authors);
            let events: Vec<Event> = client
                .database()
                .query(filter)
                .await
                .unwrap_or_default()
                .into_iter()
                .collect();

            let mut grew = false;

            this.update(cx, |this, cx| {
                let changed = this.apply_latest(self_key, events, cx);

                if this.initial {
                    this.initial = false;
                    this.ready = true;
                    cx.emit(WoTEvent::Ready);
                }

                if changed {
                    cx.emit(WoTEvent::Updated);
                    cx.notify();
                }

                grew = !covered.is_superset(&this.follows);
            })
            .ok();

            // The follow set grew beyond the covered authors,
            // reconcile once more so their contact lists are included
            if grew {
                this.update(cx, |this, cx| {
                    this.sync(cx);
                })
                .ok();
            }
        }));
    }

    /// Apply the newest stored contact list per author, returning whether the graph changed
    fn apply_latest(
        &mut self,
        self_key: PublicKey,
        events: Vec<Event>,
        cx: &mut Context<Self>,
    ) -> bool {
        if self.self_key != Some(self_key) {
            return false;
        }

        // Keep the newest contact list per author
        let mut latest: HashMap<PublicKey, Event> = HashMap::new();

        for event in events {
            if event.pubkey != self_key && (self.disabled || !self.follows.contains(&event.pubkey))
            {
                continue;
            }
            match latest.get(&event.pubkey) {
                Some(current) if current.created_at > event.created_at => continue,
                _ => {
                    latest.insert(event.pubkey, event);
                }
            }
        }

        let mut changed = false;

        for event in latest.into_values() {
            let was_disabled = self.disabled;

            changed |= if event.pubkey == self_key {
                self.apply_own(&event)
            } else {
                self.apply_contact(&event)
            };

            if was_disabled && !self.disabled {
                // The graph was cleared while disabled and has to be rebuilt
                self.sync(cx);
            }
        }

        changed
    }

    /// Apply the current user's contact list, returning whether the graph changed
    fn apply_own(&mut self, event: &Event) -> bool {
        if self.follows_at.is_some_and(|at| at > event.created_at) {
            return false;
        }

        let follows: HashSet<PublicKey> = event.tags.public_keys().take(MAX_FOLLOWS + 1).collect();

        self.store_follows(Some(event.created_at), follows)
    }

    /// Apply a followed author's contact list, returning whether the graph changed
    fn apply_contact(&mut self, event: &Event) -> bool {
        if self.disabled || !self.follows.contains(&event.pubkey) {
            return false;
        }

        let contacts = self.parse_contacts(event);

        self.set_contact_set(event.pubkey, event.created_at, contacts)
    }

    /// Parse a capped contact set from a contact list event
    fn parse_contacts(&self, event: &Event) -> HashSet<PublicKey> {
        event.tags.public_keys().take(MAX_TAGS_PER_LIST).collect()
    }

    /// Store a follow set, un-credit removed contacts, and report changes
    fn store_follows(&mut self, at: Option<Timestamp>, follows: HashSet<PublicKey>) -> bool {
        self.follows_at = at;

        if follows.len() > MAX_FOLLOWS {
            if self.disabled {
                return false;
            }

            self.follows.clear();
            self.lists.clear();
            self.reverse.clear();
            self.disabled = true;
            return true;
        }

        let removed: Vec<PublicKey> = self.follows.difference(&follows).copied().collect();
        let added: Vec<PublicKey> = follows.difference(&self.follows).copied().collect();

        let changed = !removed.is_empty() || !added.is_empty();

        self.follows = follows;
        self.disabled = false;

        for follower in removed {
            self.uncredit(&follower);
        }

        changed
    }

    /// Store a followed author's contact set, returning whether the graph changed
    fn set_contact_set(
        &mut self,
        follower: PublicKey,
        at: Timestamp,
        contacts: HashSet<PublicKey>,
    ) -> bool {
        if let Some((current, _)) = self.lists.get(&follower)
            && *current > at
        {
            return false;
        }

        let contacts: HashSet<PublicKey> = contacts
            .into_iter()
            .filter(|key| *key != follower && Some(*key) != self.self_key)
            .collect();

        let (added, removed) = match self.lists.remove(&follower) {
            Some((_, previous)) => (
                contacts
                    .difference(&previous)
                    .copied()
                    .collect::<Vec<PublicKey>>(),
                previous
                    .difference(&contacts)
                    .copied()
                    .collect::<Vec<PublicKey>>(),
            ),
            None => (contacts.iter().copied().collect(), Vec::new()),
        };

        self.lists.insert(follower, (at, contacts));

        let changed = !added.is_empty() || !removed.is_empty();

        for target in added {
            self.reverse.entry(target).or_default().insert(follower);
        }

        for target in removed {
            self.remove_credit(&follower, &target);
        }

        changed
    }

    /// Remove a contact's credits from the reverse index
    fn uncredit(&mut self, follower: &PublicKey) {
        if let Some((_, contacts)) = self.lists.remove(follower) {
            for target in contacts {
                self.remove_credit(follower, &target);
            }
        }
    }

    /// Remove a single credit from the reverse index
    fn remove_credit(&mut self, follower: &PublicKey, target: &PublicKey) {
        if let Some(creditors) = self.reverse.get_mut(target) {
            creditors.remove(follower);

            if creditors.is_empty() {
                self.reverse.remove(target);
            }
        }
    }

    /// Clear the graph on sign out or account switch
    fn reset(&mut self, cx: &mut Context<Self>) {
        self.self_key = None;
        self.follows.clear();
        self.follows_at = None;
        self.lists.clear();
        self.reverse.clear();
        self.disabled = false;
        self.ready = false;
        self.initial = false;
        self.hydration = None;

        cx.emit(WoTEvent::Updated);
        cx.notify();
    }

    /// How many of the current user's contacts follow the public key
    pub fn score(&self, public_key: &PublicKey) -> usize {
        self.reverse
            .get(public_key)
            .map_or(0, |creditors| creditors.len())
    }

    /// Whether the public key is followed by the user or by any of their contacts
    pub fn is_in_network(&self, public_key: &PublicKey) -> bool {
        self.follows.contains(public_key) || self.score(public_key) > 0
    }

    /// The current user's contacts who follow the public key
    pub fn mutuals(&self, public_key: &PublicKey) -> Vec<PublicKey> {
        self.reverse
            .get(public_key)
            .map_or_else(Vec::new, |creditors| {
                let mut contacts: Vec<PublicKey> = creditors.iter().copied().collect();
                contacts.sort();
                contacts
            })
    }

    /// Whether the initial load has finished
    pub fn is_ready(&self) -> bool {
        self.ready
    }

    /// Whether scoring is disabled due to an oversized follow set
    pub fn is_disabled(&self) -> bool {
        self.disabled
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn key(seed: usize) -> PublicKey {
        let mut bytes = [0u8; 32];
        bytes[30] = (seed >> 8) as u8;
        bytes[31] = seed as u8;

        Keys::new(SecretKey::from_slice(&bytes).expect("valid secret key")).public_key()
    }

    fn registry() -> WebOfTrust {
        WebOfTrust {
            self_key: None,
            follows: HashSet::new(),
            follows_at: None,
            lists: HashMap::new(),
            reverse: HashMap::new(),
            disabled: false,
            ready: false,
            initial: false,
            hydration: None,
            tasks: smallvec![],
            _subscriptions: smallvec![],
        }
    }

    #[test]
    fn credits_contacts_of_followed_authors() {
        let mut wot = registry();
        let (me, alice, bob, carol) = (key(1), key(2), key(3), key(4));

        wot.self_key = Some(me);

        assert!(wot.store_follows(Some(Timestamp::from_secs(10)), HashSet::from([alice, bob])));
        assert!(!wot.store_follows(Some(Timestamp::from_secs(10)), HashSet::from([alice, bob])));

        assert!(wot.set_contact_set(alice, Timestamp::from_secs(10), HashSet::from([carol]),));
        assert_eq!(wot.score(&carol), 1);
        assert_eq!(wot.mutuals(&carol), vec![alice]);
        assert!(wot.is_in_network(&carol));

        assert!(wot.set_contact_set(bob, Timestamp::from_secs(10), HashSet::from([carol]),));
        assert_eq!(wot.score(&carol), 2);
        assert_eq!(wot.mutuals(&carol), vec![alice, bob]);
    }

    #[test]
    fn ignores_older_contact_lists() {
        let mut wot = registry();
        let (me, alice, carol, dave) = (key(1), key(2), key(3), key(4));

        wot.self_key = Some(me);
        wot.store_follows(Some(Timestamp::from_secs(10)), HashSet::from([alice]));

        assert!(wot.set_contact_set(alice, Timestamp::from_secs(20), HashSet::from([carol]),));
        assert!(!wot.set_contact_set(alice, Timestamp::from_secs(10), HashSet::from([dave]),));

        assert_eq!(wot.mutuals(&carol), vec![alice]);
        assert_eq!(wot.score(&dave), 0);
    }

    #[test]
    fn uncredits_removed_follows() {
        let mut wot = registry();
        let (me, alice, bob, carol) = (key(1), key(2), key(3), key(4));

        wot.self_key = Some(me);
        wot.store_follows(Some(Timestamp::from_secs(10)), HashSet::from([alice, bob]));
        wot.set_contact_set(alice, Timestamp::from_secs(10), HashSet::from([carol]));
        wot.set_contact_set(bob, Timestamp::from_secs(10), HashSet::from([carol]));
        assert_eq!(wot.score(&carol), 2);

        assert!(wot.store_follows(Some(Timestamp::from_secs(11)), HashSet::from([bob])));

        assert_eq!(wot.score(&carol), 1);
        assert_eq!(wot.mutuals(&carol), vec![bob]);
        assert!(!wot.lists.contains_key(&alice));
    }

    #[test]
    fn excludes_self_and_follower() {
        let mut wot = registry();
        let (me, alice, carol) = (key(1), key(2), key(3));

        wot.self_key = Some(me);
        wot.store_follows(Some(Timestamp::from_secs(10)), HashSet::from([alice]));

        wot.set_contact_set(
            alice,
            Timestamp::from_secs(10),
            HashSet::from([me, alice, carol]),
        );

        assert_eq!(wot.score(&me), 0);
        assert_eq!(wot.score(&alice), 0);
        assert_eq!(wot.mutuals(&carol), vec![alice]);
    }

    #[test]
    fn disables_on_oversized_follow_set() {
        let mut wot = registry();
        let me = key(1);
        let follows: HashSet<PublicKey> = (2..(MAX_FOLLOWS + 3)).map(key).collect();

        wot.self_key = Some(me);
        wot.set_contact_set(key(2), Timestamp::from_secs(10), HashSet::from([key(3)]));
        assert!(wot.store_follows(Some(Timestamp::from_secs(10)), follows));

        assert!(wot.disabled);
        assert!(wot.follows.is_empty());
        assert!(wot.lists.is_empty());
        assert!(wot.reverse.is_empty());
    }

    #[test]
    fn caps_ingested_contact_lists() {
        let mut wot = registry();
        let (me, alice) = (key(1), key(2));

        wot.self_key = Some(me);
        wot.store_follows(Some(Timestamp::from_secs(10)), HashSet::from([alice]));

        let tags: Vec<Tag> = (3..(MAX_TAGS_PER_LIST + 4))
            .map(|seed| Tag::public_key(key(seed)))
            .collect();

        let keys = Keys::new(
            SecretKey::from_slice(&{
                let mut bytes = [0u8; 32];
                bytes[31] = 2;
                bytes
            })
            .expect("valid secret key"),
        );

        let event = EventBuilder::new(Kind::ContactList, "")
            .tags(tags)
            .finalize(&keys)
            .expect("valid event");

        let contacts = wot.parse_contacts(&event);

        assert_eq!(contacts.len(), MAX_TAGS_PER_LIST);
        assert!(!contacts.contains(&key(MAX_TAGS_PER_LIST + 3)));
    }
}