use egui::{
    text::{CCursor, CCursorRange, LayoutJob},
    text_edit::TextEditOutput,
    TextBuffer, TextEdit, TextFormat,
};
use enostr::{FullKeypair, Pubkey};
use nostrdb::{Note, NoteBuilder, NoteReply};
use std::{
    any::TypeId,
    collections::{BTreeMap, HashMap, HashSet},
    hash::{DefaultHasher, Hash, Hasher},
    ops::Range,
};
use tracing::error;

use crate::media_upload::Nip94Event;

pub struct NewPost {
    pub content: String,
    pub account: FullKeypair,
    pub media: Vec<Nip94Event>,
    pub mentions: Vec<Pubkey>,
}

fn client_variant() -> &'static str {
    #[cfg(target_os = "android")]
    {
        "Damus Android"
    }

    #[cfg(not(target_os = "android"))]
    {
        "Damus Notedeck"
    }
}

fn add_client_tag(builder: NoteBuilder<'_>) -> NoteBuilder<'_> {
    builder
        .start_tag()
        .tag_str("client")
        .tag_str(client_variant())
}

impl NewPost {
    pub fn new(
        content: String,
        account: enostr::FullKeypair,
        media: Vec<Nip94Event>,
        mentions: Vec<Pubkey>,
    ) -> Self {
        NewPost {
            content,
            account,
            media,
            mentions,
        }
    }

    pub fn to_note(&self, seckey: &[u8; 32]) -> Note<'_> {
        let mut content = self.content.clone();
        append_urls(&mut content, &self.media);

        let mut builder = add_client_tag(NoteBuilder::new()).kind(1).content(&content);

        for hashtag in Self::extract_hashtags(&self.content) {
            builder = builder.start_tag().tag_str("t").tag_str(&hashtag);
        }

        if !self.media.is_empty() {
            builder = add_imeta_tags(builder, &self.media);
        }

        if !self.mentions.is_empty() {
            builder = add_mention_tags(builder, &self.mentions);
        }

        builder.sign(seckey).build().expect("note should be ok")
    }

    pub fn to_reply(&self, seckey: &[u8; 32], replying_to: &Note) -> Note<'_> {
        let mut content = self.content.clone();
        append_urls(&mut content, &self.media);

        let builder = add_client_tag(NoteBuilder::new()).kind(1).content(&content);

        let nip10 = NoteReply::new(replying_to.tags());

        let mut builder = if let Some(root) = nip10.root() {
            builder
                .start_tag()
                .tag_str("e")
                .tag_str(&hex::encode(root.id))
                .tag_str("")
                .tag_str("root")
                .start_tag()
                .tag_str("e")
                .tag_str(&hex::encode(replying_to.id()))
                .tag_str("")
                .tag_str("reply")
                .sign(seckey)
        } else {
            // we're replying to a post that isn't in a thread,
            // just add a single reply-to-root tag
            builder
                .start_tag()
                .tag_str("e")
                .tag_str(&hex::encode(replying_to.id()))
                .tag_str("")
                .tag_str("root")
                .sign(seckey)
        };

        let mut seen_p: HashSet<&[u8; 32]> = HashSet::new();

        builder = builder
            .start_tag()
            .tag_str("p")
            .tag_str(&hex::encode(replying_to.pubkey()));

        seen_p.insert(replying_to.pubkey());

        for tag in replying_to.tags() {
            if tag.count() < 2 {
                continue;
            }

            if tag.get_unchecked(0).variant().str() != Some("p") {
                continue;
            }

            let id = if let Some(id) = tag.get_unchecked(1).variant().id() {
                id
            } else {
                continue;
            };

            if seen_p.contains(id) {
                continue;
            }

            seen_p.insert(id);

            builder = builder.start_tag().tag_str("p").tag_str(&hex::encode(id));
        }

        if !self.media.is_empty() {
            builder = add_imeta_tags(builder, &self.media);
        }

        if !self.mentions.is_empty() {
            builder = add_mention_tags(builder, &self.mentions);
        }

        builder
            .sign(seckey)
            .build()
            .expect("expected build to work")
    }

    pub fn to_quote(&self, seckey: &[u8; 32], quoting: &Note) -> Note<'_> {
        let mut new_content = format!(
            "{}\nnostr:{}",
            self.content,
            enostr::NoteId::new(*quoting.id()).to_bech().unwrap()
        );

        append_urls(&mut new_content, &self.media);

        let mut builder = NoteBuilder::new().kind(1).content(&new_content);

        for hashtag in Self::extract_hashtags(&self.content) {
            builder = builder.start_tag().tag_str("t").tag_str(&hashtag);
        }

        if !self.media.is_empty() {
            builder = add_imeta_tags(builder, &self.media);
        }

        if !self.mentions.is_empty() {
            builder = add_mention_tags(builder, &self.mentions);
        }

        builder
            .start_tag()
            .tag_str("q")
            .tag_str(&hex::encode(quoting.id()))
            .start_tag()
            .tag_str("p")
            .tag_str(&hex::encode(quoting.pubkey()))
            .sign(seckey)
            .build()
            .expect("expected build to work")
    }

    fn extract_hashtags(content: &str) -> HashSet<String> {
        let mut hashtags = HashSet::new();
        for word in
            content.split(|c: char| c.is_whitespace() || (c.is_ascii_punctuation() && c != '#'))
        {
            if word.starts_with('#') && word.len() > 1 {
                let tag = word[1..].to_lowercase();
                if !tag.is_empty() {
                    hashtags.insert(tag);
                }
            }
        }
        hashtags
    }
}

fn append_urls(content: &mut String, media: &Vec<Nip94Event>) {
    for ev in media {
        content.push(' ');
        content.push_str(&ev.url);
    }
}

fn add_mention_tags<'a>(builder: NoteBuilder<'a>, mentions: &Vec<Pubkey>) -> NoteBuilder<'a> {
    let mut builder = builder;

    for mention in mentions {
        builder = builder.start_tag().tag_str("p").tag_str(&mention.hex());
    }

    builder
}

fn add_imeta_tags<'a>(builder: NoteBuilder<'a>, media: &Vec<Nip94Event>) -> NoteBuilder<'a> {
    let mut builder = builder;
    for item in media {
        builder = builder
            .start_tag()
            .tag_str("imeta")
            .tag_str(&format!("url {}", item.url));

        if let Some(ox) = &item.ox {
            builder = builder.tag_str(&format!("ox {ox}"));
        };
        if let Some(x) = &item.x {
            builder = builder.tag_str(&format!("x {x}"));
        }
        if let Some(media_type) = &item.media_type {
            builder = builder.tag_str(&format!("m {media_type}"));
        }
        if let Some(dims) = &item.dimensions {
            builder = builder.tag_str(&format!("dim {}x{}", dims.0, dims.1));
        }
        if let Some(bh) = &item.blurhash {
            builder = builder.tag_str(&format!("blurhash {bh}"));
        }
        if let Some(thumb) = &item.thumb {
            builder = builder.tag_str(&format!("thumb {thumb}"));
        }
    }
    builder
}

type MentionKey = usize;

#[derive(Debug, Clone)]
pub struct PostBuffer {
    pub text_buffer: String,
    pub mention_indicator: char,
    pub mentions: HashMap<MentionKey, MentionInfo>,
    mentions_key: MentionKey,
    pub selected_mention: bool,

    // the start index of a mention is inclusive
    pub mention_starts: BTreeMap<usize, MentionKey>, // maps the mention start index with the correct `MentionKey`

    // the end index of a mention is exclusive
    pub mention_ends: BTreeMap<usize, MentionKey>, // maps the mention end index with the correct `MentionKey`
}

impl Default for PostBuffer {
    fn default() -> Self {
        Self {
            mention_indicator: '@',
            mentions_key: 0,
            selected_mention: false,
            text_buffer: Default::default(),
            mentions: Default::default(),
            mention_starts: Default::default(),
            mention_ends: Default::default(),
        }
    }
}

/// New cursor index (indexed by characters) after operation is performed
#[must_use = "must call MentionSelectedResponse::process"]
pub struct MentionSelectedResponse {
    pub next_cursor_index: usize,
}

impl MentionSelectedResponse {
    pub fn process(&self, ctx: &egui::Context, text_edit_output: &TextEditOutput) {
        let text_edit_id = text_edit_output.response.id;
        let Some(mut before_state) = TextEdit::load_state(ctx, text_edit_id) else {
            return;
        };

        let mut new_cursor = text_edit_output
            .galley
            .from_ccursor(CCursor::new(self.next_cursor_index));
        new_cursor.ccursor.prefer_next_row = true;

        before_state
            .cursor
            .set_char_range(Some(CCursorRange::one(CCursor::new(
                self.next_cursor_index,
            ))));

        ctx.memory_mut(|mem| mem.request_focus(text_edit_id));

        TextEdit::store_state(ctx, text_edit_id, before_state);
    }
}

impl PostBuffer {
    pub fn get_new_mentions_key(&mut self) -> usize {
        let prev = self.mentions_key;
        self.mentions_key += 1;
        prev
    }

    pub fn get_mention(&self, cursor_index: usize) -> Option<MentionIndex<'_>> {
        self.mention_ends
            .range(cursor_index..)
            .next()
            .and_then(|(_, mention_key)| {
                self.mentions
                    .get(mention_key)
                    .filter(|info| {
                        if let MentionType::Finalized(_) = info.mention_type {
                            // should exclude the last character if we're finalized
                            info.start_index <= cursor_index && cursor_index < info.end_index
                        } else {
                            info.start_index <= cursor_index && cursor_index <= info.end_index
                        }
                    })
                    .map(|info| MentionIndex {
                        index: *mention_key,
                        info,
                    })
            })
    }

    pub fn get_mention_string<'a>(&'a self, mention_key: &MentionIndex<'a>) -> &'a str {
        self.text_buffer
            .char_range(mention_key.info.start_index + 1..mention_key.info.end_index)
        // don't include the delim
    }

    pub fn select_full_mention(&mut self, mention_key: usize, pk: Pubkey) {
        if let Some(info) = self.mentions.get_mut(&mention_key) {
            info.mention_type = MentionType::Finalized(pk);
            self.selected_mention = true;
        } else {
            error!("Error selecting mention for index: {mention_key}. Have the following mentions: {:?}", self.mentions);
        }
    }

    pub fn select_mention_and_replace_name(
        &mut self,
        mention_key: usize,
        full_name: &str,
        pk: Pubkey,
    ) -> Option<MentionSelectedResponse> {
        let Some(info) = self.mentions.get(&mention_key) else {
            error!("Error selecting mention for index: {mention_key}. Have the following mentions: {:?}", self.mentions);
            return None;
        };
        let text_start_index = info.start_index + 1; // increment by one to exclude the mention indicator, '@'
        self.delete_char_range(text_start_index..info.end_index);
        let text_chars_inserted = self.insert_text(full_name, text_start_index);
        self.select_full_mention(mention_key, pk);

        let space_chars_inserted = self.insert_text(" ", text_start_index + text_chars_inserted);

        Some(MentionSelectedResponse {
            next_cursor_index: text_start_index + text_chars_inserted + space_chars_inserted,
        })
    }

    pub fn delete_mention(&mut self, mention_key: usize) {
        if let Some(mention_info) = self.mentions.get(&mention_key) {
            self.mention_starts.remove(&mention_info.start_index);
            self.mention_ends.remove(&mention_info.end_index);
            self.mentions.remove(&mention_key);
        }
    }

    pub fn is_empty(&self) -> bool {
        self.text_buffer.is_empty()
    }

    pub fn output(&self) -> PostOutput {
        let mut out = self.text_buffer.clone();
        let mut mentions = Vec::new();
        for (cur_end_ind, mention_ind) in self.mention_ends.iter().rev() {
            if let Some(info) = self.mentions.get(mention_ind) {
                if let MentionType::Finalized(pk) = info.mention_type {
                    if let Some(bech) = pk.npub() {
                        if let Some(byte_range) =
                            char_indices_to_byte(&out, info.start_index..*cur_end_ind)
                        {
                            out.replace_range(byte_range, &format!("nostr:{bech}"));
                            mentions.push(pk);
                        }
                    }
                }
            }
        }
        mentions.reverse();

        PostOutput {
            text: out,
            mentions,
        }
    }

    pub fn to_layout_job(&self, ui: &egui::Ui) -> LayoutJob {
        let mut job = LayoutJob::default();
        let colored_fmt = default_text_format_colored(ui, notedeck_ui::colors::PINK);

        let mut prev_text_char_index = 0;
        let mut prev_text_byte_index = 0;
        for (start_char_index, mention_ind) in &self.mention_starts {
            if let Some(info) = self.mentions.get(mention_ind) {
                if matches!(info.mention_type, MentionType::Finalized(_)) {
                    let end_char_index = info.end_index;

                    let char_indices = prev_text_char_index..*start_char_index;
                    if let Some(byte_indicies) =
                        char_indices_to_byte(&self.text_buffer, char_indices.clone())
                    {
                        if let Some(prev_text) = self.text_buffer.get(byte_indicies.clone()) {
                            job.append(prev_text, 0.0, default_text_format(ui));
                            prev_text_char_index = *start_char_index;
                            prev_text_byte_index = byte_indicies.end;
                        }
                    }

                    let char_indices = *start_char_index..end_char_index;
                    if let Some(byte_indicies) =
                        char_indices_to_byte(&self.text_buffer, char_indices.clone())
                    {
                        if let Some(cur_text) = self.text_buffer.get(byte_indicies.clone()) {
                            job.append(cur_text, 0.0, colored_fmt.clone());
                            prev_text_char_index = end_char_index;
                            prev_text_byte_index = byte_indicies.end;
                        }
                    }
                }
            }
        }

        if prev_text_byte_index < self.text_buffer.len() {
            if let Some(cur_text) = self.text_buffer.get(prev_text_byte_index..) {
                job.append(cur_text, 0.0, default_text_format(ui));
            } else {
                error!(
                    "could not retrieve substring from [{} to {}) in PostBuffer::text_buffer",
                    prev_text_byte_index,
                    self.text_buffer.len()
                );
            }
        }

        job
    }

    pub fn need_new_layout(&self, cache: Option<&(String, LayoutJob)>) -> bool {
        if let Some((text, _)) = cache {
            if self.selected_mention {
                return true;
            }

            self.text_buffer != *text
        } else {
            true
        }
    }
}

fn char_indices_to_byte(text: &str, char_range: Range<usize>) -> Option<Range<usize>> {
    let mut char_indices = text.char_indices();

    let start = char_indices.nth(char_range.start)?.0;
    let end = if char_range.end < text.chars().count() {
        char_indices.nth(char_range.end - char_range.start - 1)?.0
    } else {
        text.len()
    };

    Some(start..end)
}

pub fn downcast_post_buffer(buffer: &dyn TextBuffer) -> Option<&PostBuffer> {
    let mut hasher = DefaultHasher::new();
    TypeId::of::<PostBuffer>().hash(&mut hasher);
    let post_id = hasher.finish() as usize;

    if buffer.type_id() == post_id {
        unsafe { Some(&*(buffer as *const dyn TextBuffer as *const PostBuffer)) }
    } else {
        None
    }
}

fn default_text_format(ui: &egui::Ui) -> TextFormat {
    default_text_format_colored(
        ui,
        ui.visuals()
            .override_text_color
            .unwrap_or_else(|| ui.visuals().widgets.inactive.text_color()),
    )
}

fn default_text_format_colored(ui: &egui::Ui, color: egui::Color32) -> TextFormat {
    TextFormat::simple(egui::FontSelection::default().resolve(ui.style()), color)
}

pub struct PostOutput {
    pub text: String,
    pub mentions: Vec<Pubkey>,
}

#[derive(Debug)]
pub struct MentionIndex<'a> {
    pub index: usize,
    pub info: &'a MentionInfo,
}

#[derive(Clone, Debug, PartialEq)]
pub enum MentionType {
    Pending,
    Finalized(Pubkey),
}

impl TextBuffer for PostBuffer {
    fn is_mutable(&self) -> bool {
        true
    }

    fn as_str(&self) -> &str {
        self.text_buffer.as_str()
    }

    fn insert_text(&mut self, text: &str, char_index: usize) -> usize {
        if text.is_empty() {
            return 0;
        }
        let text_num_chars = text.chars().count();
        self.text_buffer.insert_text(text, char_index);

        // the text was inserted before or inside these mentions. We need to at least move their ends
        let pending_ends_to_update: Vec<usize> = self
            .mention_ends
            .range(char_index..)
            .filter(|(k, v)| {
                let is_last = **k == char_index;
                let is_finalized = if let Some(info) = self.mentions.get(*v) {
                    matches!(info.mention_type, MentionType::Finalized(_))
                } else {
                    false
                };
                !(is_last && is_finalized)
            })
            .map(|(&k, _)| k)
            .collect();

        let mut break_mentions = Vec::new();
        for cur_end in pending_ends_to_update {
            let mention_key = if let Some(mention_key) = self.mention_ends.get(&cur_end) {
                *mention_key
            } else {
                continue;
            };

            self.mention_ends.remove(&cur_end);

            let new_end = cur_end + text_num_chars;
            self.mention_ends.insert(new_end, mention_key);
            // replaced the current end with the new value

            if let Some(mention_info) = self.mentions.get_mut(&mention_key) {
                if mention_info.start_index >= char_index {
                    // the text is being inserted before this mention. move the start index as well
                    self.mention_starts.remove(&mention_info.start_index);
                    let new_start = mention_info.start_index + text_num_chars;
                    self.mention_starts.insert(new_start, mention_key);
                    mention_info.start_index = new_start;
                } else {
                    if char_index == mention_info.end_index
                        && first_is_desired_char(&self.text_buffer, text, char_index, ' ')
                    {
                        // if the user wrote a double space at the end of the mention, break it
                        break_mentions.push(mention_key);
                    }

                    // text is being inserted inside this mention. Make sure it is in the pending state
                    mention_info.mention_type = MentionType::Pending;
                }

                mention_info.end_index = new_end;
            } else {
                error!("Could not find mention at index {}", mention_key);
            }
        }

        for mention_key in break_mentions {
            self.delete_mention(mention_key);
        }

        if first_is_desired_char(&self.text_buffer, text, char_index, self.mention_indicator) {
            // if a mention already exists where we're inserting the delim, remove it
            let to_remove = self.get_mention(char_index).map(|old_mention| {
                (
                    old_mention.index,
                    old_mention.info.start_index..old_mention.info.end_index,
                )
            });

            if let Some((key, range)) = to_remove {
                self.mention_ends.remove(&range.end);
                self.mention_starts.remove(&range.start);
                self.mentions.remove(&key);
            }

            let start_index = char_index;
            let end_index = char_index + text_num_chars;
            let mention_key = self.get_new_mentions_key();
            self.mentions.insert(
                mention_key,
                MentionInfo {
                    start_index,
                    end_index,
                    mention_type: MentionType::Pending,
                },
            );
            self.mention_starts.insert(start_index, mention_key);
            self.mention_ends.insert(end_index, mention_key);
        }

        text_num_chars
    }

    fn delete_char_range(&mut self, char_range: Range<usize>) {
        let deletion_num_chars = char_range.len();
        let Range {
            start: deletion_start,
            end: deletion_end,
        } = char_range;

        self.text_buffer.delete_char_range(char_range);

        // these mentions will be affected by the deletion
        let ends_to_update: Vec<usize> = self
            .mention_ends
            .range(deletion_start..)
            .map(|(&k, _)| k)
            .collect();

        for cur_mention_end in ends_to_update {
            let mention_key = match &self.mention_ends.get(&cur_mention_end) {
                Some(ind) => **ind,
                None => continue,
            };
            let cur_mention_start = match self.mentions.get(&mention_key) {
                Some(i) => i.start_index,
                None => {
                    error!("Could not find mention at index {}", mention_key);
                    continue;
                }
            };

            if cur_mention_end <= deletion_start {
                // nothing happens to this mention
                continue;
            }

            let status = if cur_mention_start >= deletion_start {
                if cur_mention_start >= deletion_end {
                    // mention falls after the range
                    // need to shift both start and end

                    DeletionStatus::ShiftStartAndEnd(
                        cur_mention_start - deletion_num_chars,
                        cur_mention_end - deletion_num_chars,
                    )
                } else {
                    // fully delete mention

                    DeletionStatus::FullyRemove
                }
            } else if cur_mention_end > deletion_end {
                // inner partial delete

                DeletionStatus::ShiftEnd(cur_mention_end - deletion_num_chars)
            } else {
                // outer partial delete

                DeletionStatus::ShiftEnd(deletion_start)
            };

            match status {
                DeletionStatus::FullyRemove => {
                    self.mention_starts.remove(&cur_mention_start);
                    self.mention_ends.remove(&cur_mention_end);
                    self.mentions.remove(&mention_key);
                }
                DeletionStatus::ShiftEnd(new_end)
                | DeletionStatus::ShiftStartAndEnd(_, new_end) => {
                    let mention_info = match self.mentions.get_mut(&mention_key) {
                        Some(i) => i,
                        None => {
                            error!("Could not find mention at index {}", mention_key);
                            continue;
                        }
                    };

                    self.mention_ends.remove(&cur_mention_end);
                    self.mention_ends.insert(new_end, mention_key);
                    mention_info.end_index = new_end;

                    if let DeletionStatus::ShiftStartAndEnd(new_start, _) = status {
                        self.mention_starts.remove(&cur_mention_start);
                        self.mention_starts.insert(new_start, mention_key);
                        mention_info.start_index = new_start;
                    }

                    if let DeletionStatus::ShiftEnd(_) = status {
                        mention_info.mention_type = MentionType::Pending;
                    }
                }
            }
        }
    }

    fn type_id(&self) -> usize {
        let mut hasher = DefaultHasher::new();
        TypeId::of::<PostBuffer>().hash(&mut hasher);
        hasher.finish() as usize
    }
}

fn first_is_desired_char(
    full_text: &str,
    new_text: &str,
    new_text_index: usize,
    desired: char,
) -> bool {
    new_text.chars().next().is_some_and(|c| {
        c == desired
            && (new_text_index == 0 || full_text.chars().nth(new_text_index - 1) == Some(' '))
    })
}

#[derive(Debug)]
enum DeletionStatus {
    FullyRemove,
    ShiftEnd(usize),
    ShiftStartAndEnd(usize, usize),
}

#[derive(Debug, PartialEq, Clone)]
pub struct MentionInfo {
    pub start_index: usize,
    pub end_index: usize,
    pub mention_type: MentionType,
}

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

    impl MentionInfo {
        pub fn bounds(&self) -> Range<usize> {
            self.start_index..self.end_index
        }
    }

    const JB55: fn() -> Pubkey = || {
        Pubkey::from_hex("32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245")
            .unwrap()
    };
    const KK: fn() -> Pubkey = || {
        Pubkey::from_hex("4a0510f26880d40e432f4865cb5714d9d3c200ca6ebb16b418ae6c555f574967")
            .unwrap()
    };

    #[derive(PartialEq, Clone, Debug)]
    struct MentionExample {
        text: String,
        mention1: Option<MentionInfo>,
        mention2: Option<MentionInfo>,
        mention3: Option<MentionInfo>,
        mention4: Option<MentionInfo>,
    }

    fn apply_mention_example(buf: &mut PostBuffer) -> MentionExample {
        buf.insert_text("test ", 0);
        buf.insert_text("@jb55", 5);
        buf.select_full_mention(0, JB55());
        buf.insert_text(" test ", 10);
        buf.insert_text("@vrod", 16);
        buf.select_full_mention(1, JB55());
        buf.insert_text(" test ", 21);
        buf.insert_text("@elsat", 27);
        buf.select_full_mention(2, JB55());
        buf.insert_text(" test ", 33);
        buf.insert_text("@kernelkind", 39);
        buf.select_full_mention(3, KK());
        buf.insert_text(" test", 50);

        let mention1_bounds = 5..10;
        let mention2_bounds = 16..21;
        let mention3_bounds = 27..33;
        let mention4_bounds = 39..50;

        let text = "test @jb55 test @vrod test @elsat test @kernelkind test";

        assert_eq!(buf.as_str(), text);
        assert_eq!(buf.mentions.len(), 4);

        let mention1 = buf.mentions.get(&0).unwrap();
        assert_eq!(mention1.bounds(), mention1_bounds);
        assert_eq!(mention1.mention_type, MentionType::Finalized(JB55()));
        let mention2 = buf.mentions.get(&1).unwrap();
        assert_eq!(mention2.bounds(), mention2_bounds);
        assert_eq!(mention2.mention_type, MentionType::Finalized(JB55()));
        let mention3 = buf.mentions.get(&2).unwrap();
        assert_eq!(mention3.bounds(), mention3_bounds);
        assert_eq!(mention3.mention_type, MentionType::Finalized(JB55()));
        let mention4 = buf.mentions.get(&3).unwrap();
        assert_eq!(mention4.bounds(), mention4_bounds);
        assert_eq!(mention4.mention_type, MentionType::Finalized(KK()));

        let text = text.to_owned();
        MentionExample {
            text,
            mention1: Some(mention1.clone()),
            mention2: Some(mention2.clone()),
            mention3: Some(mention3.clone()),
            mention4: Some(mention4.clone()),
        }
    }

    impl PostBuffer {
        fn to_example(&self) -> MentionExample {
            let mention1 = self.mentions.get(&0).cloned();
            let mention2 = self.mentions.get(&1).cloned();
            let mention3 = self.mentions.get(&2).cloned();
            let mention4 = self.mentions.get(&3).cloned();

            MentionExample {
                text: self.text_buffer.clone(),
                mention1,
                mention2,
                mention3,
                mention4,
            }
        }
    }

    impl MentionInfo {
        fn shifted(mut self, offset: usize) -> Self {
            self.end_index -= offset;
            self.start_index -= offset;

            self
        }
    }

    #[test]
    fn test_extract_hashtags() {
        let test_cases = vec![
            ("Hello #world", vec!["world"]),
            ("Multiple #tags #in #one post", vec!["tags", "in", "one"]),
            ("No hashtags here", vec![]),
            ("#tag1 with #tag2!", vec!["tag1", "tag2"]),
            ("Ignore # empty", vec![]),
            ("Testing emoji #🍌banana", vec!["🍌banana"]),
            ("Testing emoji #🍌", vec!["🍌"]),
            ("Duplicate #tag #tag #tag", vec!["tag"]),
            ("Mixed case #TaG #tag #TAG", vec!["tag"]),
            (
                "#tag1, #tag2, #tag3 with commas",
                vec!["tag1", "tag2", "tag3"],
            ),
            ("Separated by commas #tag1,#tag2", vec!["tag1", "tag2"]),
            ("Separated by periods #tag1.#tag2", vec!["tag1", "tag2"]),
            ("Separated by semicolons #tag1;#tag2", vec!["tag1", "tag2"]),
        ];

        for (input, expected) in test_cases {
            let result = NewPost::extract_hashtags(input);
            let expected: HashSet<String> = expected.into_iter().map(String::from).collect();
            assert_eq!(result, expected, "Failed for input: {}", input);
        }
    }

    #[test]
    fn test_insert_single_mention() {
        let mut buf = PostBuffer::default();
        buf.insert_text("test ", 0);
        buf.insert_text("@", 5);
        assert!(buf.get_mention(5).is_some());
        buf.insert_text("jb55", 6);
        assert_eq!(buf.as_str(), "test @jb55");
        assert_eq!(buf.mentions.len(), 1);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 5..10);

        buf.select_full_mention(0, JB55());

        assert_eq!(
            buf.mentions.get(&0).unwrap().mention_type,
            MentionType::Finalized(JB55())
        );
    }

    #[test]
    fn test_insert_mention_with_space() {
        let mut buf = PostBuffer::default();
        buf.insert_text("@", 0);
        buf.insert_text("jb", 1);
        buf.insert_text("55", 3);
        assert!(buf.get_mention(1).is_some());
        assert_eq!(buf.mentions.len(), 1);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 0..5);
        buf.insert_text(" test", 5);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 0..10);
        assert_eq!(buf.as_str(), "@jb55 test");

        buf.select_full_mention(0, JB55());

        assert_eq!(
            buf.mentions.get(&0).unwrap().mention_type,
            MentionType::Finalized(JB55())
        );
    }

    #[test]
    fn test_insert_mention_with_emojis() {
        let mut buf = PostBuffer::default();
        buf.insert_text("test ", 0);
        buf.insert_text("@test😀 🏴‍☠️ :D", 5);
        buf.select_full_mention(0, JB55());
        buf.insert_text(" test", 19);

        assert_eq!(buf.as_str(), "test @test😀 🏴‍☠️ :D test");
        let mention = buf.mentions.get(&0).unwrap();
        assert_eq!(
            *mention,
            MentionInfo {
                start_index: 5,
                end_index: 19,
                mention_type: MentionType::Finalized(JB55())
            }
        );
    }

    #[test]
    fn test_insert_partial_to_full() {
        let mut buf = PostBuffer::default();
        buf.insert_text("@jb", 0);
        assert_eq!(buf.mentions.len(), 1);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 0..3);
        buf.select_mention_and_replace_name(0, "jb55", JB55());
        assert_eq!(buf.as_str(), "@jb55 ");

        buf.insert_text("test", 6);
        assert_eq!(buf.as_str(), "@jb55 test");

        assert_eq!(buf.mentions.len(), 1);
        let mention = buf.mentions.get(&0).unwrap();
        assert_eq!(mention.bounds(), 0..5);
        assert_eq!(mention.mention_type, MentionType::Finalized(JB55()));
    }

    #[test]
    fn test_insert_mention_after_text() {
        let mut buf = PostBuffer::default();
        buf.insert_text("test text here", 0);
        buf.insert_text("@jb55", 4);

        assert!(buf.mentions.is_empty());
    }

    #[test]
    fn test_insert_mention_with_space_after_text() {
        let mut buf = PostBuffer::default();
        buf.insert_text("test  text here", 0);
        buf.insert_text("@jb55", 5);

        assert!(buf.get_mention(5).is_some());
        assert_eq!(buf.mentions.len(), 1);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 5..10);
        assert_eq!("test @jb55 text here", buf.as_str());

        buf.select_full_mention(0, JB55());

        assert_eq!(
            buf.mentions.get(&0).unwrap().mention_type,
            MentionType::Finalized(JB55())
        );
    }

    #[test]
    fn test_insert_mention_then_text() {
        let mut buf = PostBuffer::default();

        buf.insert_text("@jb55", 0);
        buf.select_full_mention(0, JB55());

        buf.insert_text(" test", 5);
        assert_eq!(buf.as_str(), "@jb55 test");
        assert_eq!(buf.mentions.len(), 1);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 0..5);
        assert!(buf.get_mention(6).is_none());
    }

    #[test]
    fn test_insert_two_mentions() {
        let mut buf = PostBuffer::default();

        buf.insert_text("@jb55", 0);
        buf.select_full_mention(0, JB55());
        buf.insert_text(" test ", 5);
        buf.insert_text("@kernelkind", 11);
        buf.select_full_mention(1, KK());
        buf.insert_text(" test", 22);

        assert_eq!(buf.as_str(), "@jb55 test @kernelkind test");
        assert_eq!(buf.mentions.len(), 2);
        assert_eq!(buf.mentions.get(&0).unwrap().bounds(), 0..5);
        assert_eq!(buf.mentions.get(&1).unwrap().bounds(), 11..22);
    }

    #[test]
    fn test_insert_into_mention() {
        let mut buf = PostBuffer::default();

        buf.insert_text("@jb55", 0);
        buf.select_full_mention(0, JB55());
        buf.insert_text(" test", 5);

        assert_eq!(buf.mentions.len(), 1);
        let mention = buf.mentions.get(&0).unwrap();
        assert_eq!(mention.bounds(), 0..5);
        assert_eq!(mention.mention_type, MentionType::Finalized(JB55()));

        buf.insert_text("oops", 2);
        assert_eq!(buf.as_str(), "@joopsb55 test");
        assert_eq!(buf.mentions.len(), 1);
        let mention = buf.mentions.get(&0).unwrap();
        assert_eq!(mention.bounds(), 0..9);
        assert_eq!(mention.mention_type, MentionType::Pending);
    }

    #[test]
    fn test_insert_mention_inside_mention() {
        let mut buf = PostBuffer::default();

        buf.insert_text("@jb55", 0);
        buf.select_full_mention(0, JB55());
        buf.insert_text(" test", 5);

        assert_eq!(buf.mentions.len(), 1);
        let mention = buf.mentions.get(&0).unwrap();
        assert_eq!(mention.bounds(), 0..5);
        assert_eq!(mention.mention_type, MentionType::Finalized(JB55()));

        buf.insert_text(" ", 3);
        buf.insert_text("@oops", 4);
        assert_eq!(buf.as_str(), "@jb @oops55 test");
        assert_eq!(buf.mentions.len(), 1);
        assert_eq!(buf.mention_ends.len(), 1);
        assert_eq!(buf.mention_starts.len(), 1);
        let mention = buf.mentions.get(&1).unwrap();
        assert_eq!(mention.bounds(), 4..9);
        assert_eq!(mention.mention_type, MentionType::Pending);
    }

    #[test]
    fn test_delete_before_mention() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        let range = 1..5;
        let len = range.len();
        buf.delete_char_range(range);

        assert_eq!(
            MentionExample {
                text: "t@jb55 test @vrod test @elsat test @kernelkind test".to_owned(),
                mention1: Some(before.mention1.clone().unwrap().shifted(len)),
                mention2: Some(before.mention2.clone().unwrap().shifted(len)),
                mention3: Some(before.mention3.clone().unwrap().shifted(len)),
                mention4: Some(before.mention4.clone().unwrap().shifted(len)),
            },
            buf.to_example(),
        );
    }

    #[test]
    fn test_delete_after_mention() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        let range = 11..16;
        let len = range.len();
        buf.delete_char_range(range);

        assert_eq!(
            MentionExample {
                text: "test @jb55 @vrod test @elsat test @kernelkind test".to_owned(),
                mention2: Some(before.mention2.clone().unwrap().shifted(len)),
                mention3: Some(before.mention3.clone().unwrap().shifted(len)),
                mention4: Some(before.mention4.clone().unwrap().shifted(len)),
                ..before.clone()
            },
            buf.to_example(),
        );
    }

    #[test]
    fn test_delete_mention_partial_inner() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        let range = 17..20;
        let len = range.len();
        buf.delete_char_range(range);

        assert_eq!(
            MentionExample {
                text: "test @jb55 test @d test @elsat test @kernelkind test".to_owned(),
                mention2: Some(MentionInfo {
                    start_index: 16,
                    end_index: 18,
                    mention_type: MentionType::Pending,
                }),
                mention3: Some(before.mention3.clone().unwrap().shifted(len)),
                mention4: Some(before.mention4.clone().unwrap().shifted(len)),
                ..before.clone()
            },
            buf.to_example(),
        );
    }

    #[test]
    fn test_delete_mention_partial_outer() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        let range = 17..27;
        let len = range.len();
        buf.delete_char_range(range);

        assert_eq!(
            MentionExample {
                text: "test @jb55 test @@elsat test @kernelkind test".to_owned(),
                mention2: Some(MentionInfo {
                    start_index: 16,
                    end_index: 17,
                    mention_type: MentionType::Pending
                }),
                mention3: Some(before.mention3.clone().unwrap().shifted(len)),
                mention4: Some(before.mention4.clone().unwrap().shifted(len)),
                ..before.clone()
            },
            buf.to_example(),
        );
    }

    #[test]
    fn test_delete_mention_partial_and_full() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        buf.delete_char_range(17..28);

        assert_eq!(
            MentionExample {
                text: "test @jb55 test @elsat test @kernelkind test".to_owned(),
                mention2: Some(MentionInfo {
                    end_index: 17,
                    mention_type: MentionType::Pending,
                    ..before.mention2.clone().unwrap()
                }),
                mention3: None,
                mention4: Some(MentionInfo {
                    start_index: 28,
                    end_index: 39,
                    ..before.mention4.clone().unwrap()
                }),
                ..before.clone()
            },
            buf.to_example()
        )
    }

    #[test]
    fn test_delete_mention_full_one() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        let range = 10..26;
        let len = range.len();
        buf.delete_char_range(range);

        assert_eq!(
            MentionExample {
                text: "test @jb55 @elsat test @kernelkind test".to_owned(),
                mention2: None,
                mention3: Some(before.mention3.clone().unwrap().shifted(len)),
                mention4: Some(before.mention4.clone().unwrap().shifted(len)),
                ..before.clone()
            },
            buf.to_example()
        );
    }

    #[test]
    fn test_delete_mention_full_two() {
        let mut buf = PostBuffer::default();
        let before = apply_mention_example(&mut buf);

        buf.delete_char_range(11..28);

        assert_eq!(
            MentionExample {
                text: "test @jb55 elsat test @kernelkind test".to_owned(),
                mention2: None,
                mention3: None,
                mention4: Some(MentionInfo {
                    start_index: 22,
                    end_index: 33,
                    ..before.mention4.clone().unwrap()
                }),
                ..before.clone()
            },
            buf.to_example()
        )
    }

    #[test]
    fn test_two_then_one_between() {
        let mut buf = PostBuffer::default();

        buf.insert_text("@jb", 0);
        buf.select_mention_and_replace_name(0, "jb55", JB55());
        buf.insert_text("test ", 6);
        assert_eq!(buf.as_str(), "@jb55 test ");
        buf.insert_text("@kernel", 11);
        buf.select_mention_and_replace_name(1, "KernelKind", KK());
        assert_eq!(buf.as_str(), "@jb55 test @KernelKind ");

        buf.insert_text("test", 23);
        assert_eq!(buf.as_str(), "@jb55 test @KernelKind test");

        assert_eq!(buf.mentions.len(), 2);

        buf.insert_text("@els", 6);
        assert_eq!(buf.as_str(), "@jb55 @elstest @KernelKind test");

        assert_eq!(buf.mentions.len(), 3);
        assert_eq!(buf.mentions.get(&2).unwrap().bounds(), 6..10);
        buf.select_mention_and_replace_name(2, "elsat", JB55());
        assert_eq!(buf.as_str(), "@jb55 @elsat test @KernelKind test");

        let jb_mention = buf.mentions.get(&0).unwrap();
        let kk_mention = buf.mentions.get(&1).unwrap();
        let el_mention = buf.mentions.get(&2).unwrap();
        assert_eq!(jb_mention.bounds(), 0..5);
        assert_eq!(jb_mention.mention_type, MentionType::Finalized(JB55()));
        assert_eq!(kk_mention.bounds(), 18..29);
        assert_eq!(kk_mention.mention_type, MentionType::Finalized(KK()));
        assert_eq!(el_mention.bounds(), 6..12);
        assert_eq!(el_mention.mention_type, MentionType::Finalized(JB55()));
    }

    #[test]
    fn note_single_mention() {
        let mut buf = PostBuffer::default();
        buf.insert_text("@jb55", 0);
        buf.select_full_mention(0, JB55());

        let out = buf.output();
        let kp = FullKeypair::generate();
        let post = NewPost::new(out.text, kp.clone(), Vec::new(), out.mentions);
        let note = post.to_note(&kp.pubkey);

        let mut tags_iter = note.tags().iter();
        tags_iter.next(); //ignore the first one, the client tag
        let tag = tags_iter.next().unwrap();
        assert_eq!(tag.count(), 2);
        assert_eq!(tag.get(0).unwrap().str().unwrap(), "p");
        assert_eq!(tag.get(1).unwrap().id().unwrap(), JB55().bytes());
        assert!(tags_iter.next().is_none());
        assert_eq!(
            note.content(),
            "nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s"
        );
    }

    #[test]
    fn note_two_mentions() {
        let mut buf = PostBuffer::default();

        buf.insert_text("@jb55", 0);
        buf.select_full_mention(0, JB55());
        buf.insert_text(" test ", 5);
        buf.insert_text("@KernelKind", 11);
        buf.select_full_mention(1, KK());
        buf.insert_text(" test", 22);
        assert_eq!(buf.as_str(), "@jb55 test @KernelKind test");

        let out = buf.output();
        let kp = FullKeypair::generate();
        let post = NewPost::new(out.text, kp.clone(), Vec::new(), out.mentions);
        let note = post.to_note(&kp.pubkey);

        let mut tags_iter = note.tags().iter();
        tags_iter.next(); //ignore the first one, the client tag
        let jb_tag = tags_iter.next().unwrap();
        assert_eq!(jb_tag.count(), 2);
        assert_eq!(jb_tag.get(0).unwrap().str().unwrap(), "p");
        assert_eq!(jb_tag.get(1).unwrap().id().unwrap(), JB55().bytes());

        let kk_tag = tags_iter.next().unwrap();
        assert_eq!(kk_tag.count(), 2);
        assert_eq!(kk_tag.get(0).unwrap().str().unwrap(), "p");
        assert_eq!(kk_tag.get(1).unwrap().id().unwrap(), KK().bytes());

        assert!(tags_iter.next().is_none());

        assert_eq!(note.content(), "nostr:npub1xtscya34g58tk0z605fvr788k263gsu6cy9x0mhnm87echrgufzsevkk5s test nostr:npub1fgz3pungsr2quse0fpjuk4c5m8fuyqx2d6a3ddqc4ek92h6hf9ns0mjeck test");
    }

    #[test]
    fn note_one_pending() {
        let mut buf = PostBuffer::default();

        buf.insert_text("test ", 0);
        buf.insert_text("@jb55 test", 5);

        let out = buf.output();
        let kp = FullKeypair::generate();
        let post = NewPost::new(out.text, kp.clone(), Vec::new(), out.mentions);
        let note = post.to_note(&kp.pubkey);

        let mut tags_iter = note.tags().iter();
        tags_iter.next(); //ignore the first one, the client tag
        assert!(tags_iter.next().is_none());
        assert_eq!(note.content(), "test @jb55 test");
    }
}