simplemailclient 0.2.3

use std::cell::RefCell;
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Local};
use uuid::Uuid;
use anyhow::{Context, Result};
use crate::config::Config;

// ─── Domain Types ─────────────────────────────────────────────────────────────

/// A file attachment, stored separately from the message body.
/// The raw bytes are base64-encoded so binary files (zip, images, …) survive
/// JSON serialization intact.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Attachment {
    pub filename: String,
    pub size: u64,
    pub mime_type: String,
    /// Base64-encoded file content.
    pub data: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    pub id: String,
    pub from: String,
    pub to: String,
    pub body: String,
    pub timestamp: DateTime<Local>,
    pub read: bool,
    pub starred: bool,
    pub folder: Folder,
    /// IMAP UID of this message (set for received messages; None for sent).
    #[serde(default)]
    pub uid: Option<u32>,
    /// RFC 2822 Message-ID header value — used to detect duplicates on re-sync.
    #[serde(default)]
    pub message_id: Option<String>,
    /// Files attached to this message, kept separate from the body text.
    #[serde(default)]
    pub attachments: Vec<Attachment>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum Folder {
    Inbox,
    Sent,
    Starred,
    Trash,
}

impl Folder {
    pub fn label(&self) -> &'static str {
        match self {
            Folder::Inbox   => "Inbox",
            Folder::Sent    => "Sent",
            Folder::Starred => "Starred",
            Folder::Trash   => "Trash",
        }
    }
}

/// A contact entry.  Contacts are keyed by domain+user and assigned a stable
/// numeric ID.  They are created automatically from any address we send to or
/// receive from.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Contact {
    /// Stable numeric ID (e.g. "1", "2", …)
    pub id: String,
    /// Full email address
    pub address: String,
    /// The local part  (user)
    pub user: String,
    /// The domain part
    pub domain: String,
    /// Optional display name, populated if the remote sends a friendly name
    pub display_name: Option<String>,
    /// User-defined short alias, e.g. "bob". Used for fast addressing in compose.
    #[serde(default)]
    pub nickname: Option<String>,
}

#[derive(Debug, Serialize, Deserialize, Default)]
struct MailData {
    messages: Vec<Message>,
    /// address → Contact
    contacts: HashMap<String, Contact>,
    /// monotonic counter for contact IDs
    next_contact_id: u64,
}

// ─── MailStore ────────────────────────────────────────────────────────────────

pub struct MailStore {
    data_path: PathBuf,
    data: RefCell<MailData>,
}

impl MailStore {
    pub fn new(cfg: &Config) -> Result<Self> {
        let data_dir = dirs::data_local_dir()
            .unwrap_or_else(|| PathBuf::from("."))
            .join("mail-rs");
        fs::create_dir_all(&data_dir)?;
        let data_path = data_dir.join("mailbox.json");

        let data = if data_path.exists() {
            let raw = fs::read_to_string(&data_path)
                .with_context(|| format!("Cannot read {}", data_path.display()))?;
            serde_json::from_str(&raw).unwrap_or_default()
        } else {
            MailData::default()
        };

        // Ensure our own identity is in the contact book
        let store = Self { data_path, data: RefCell::new(data) };
        store.ensure_contact(&cfg.identity)?;
        // Re-parse any messages stored with raw MIME bodies (one-time migration).
        store.migrate_mime_bodies()?;
        Ok(store)
    }

    /// Walk all stored messages and re-parse any whose body looks like a raw
    /// MIME multipart (contains a boundary marker). Fixes messages that were
    /// stored before the mailparse-based extraction was in place.
    fn migrate_mime_bodies(&self) -> Result<()> {
        let needs_fix: Vec<usize> = self
            .data
            .borrow()
            .messages
            .iter()
            .enumerate()
            .filter(|(_, m)| looks_like_raw_mime(&m.body))
            .map(|(i, _)| i)
            .collect();

        if needs_fix.is_empty() {
            return Ok(());
        }

        for i in needs_fix {
            // Re-parse using mailparse to get the clean text.
            let raw_body = self.data.borrow().messages[i].body.clone();
            let cleaned = crate::transport::extract_body_text_pub(raw_body.as_bytes());
            if !cleaned.is_empty() && cleaned != raw_body {
                self.data.borrow_mut().messages[i].body = cleaned;
            }
        }

        self.save()?;
        Ok(())
    }

    // ── Persistence ──────────────────────────────────────────────────────────

    fn save(&self) -> Result<()> {
        let json = serde_json::to_string_pretty(&*self.data.borrow())?;
        fs::write(&self.data_path, json)?;
        Ok(())
    }

    // ── Contact Management ───────────────────────────────────────────────────

    /// Ensure an address is registered; return its contact.
    /// If new, parse user@domain and assign the next numeric ID.
    pub fn ensure_contact(&self, address: &str) -> Result<Contact> {
        {
            let data = self.data.borrow();
            if let Some(c) = data.contacts.get(address) {
                return Ok(c.clone());
            }
        }

        let (user, domain) = split_address(address);
        let mut data = self.data.borrow_mut();
        data.next_contact_id += 1;
        let contact = Contact {
            id: data.next_contact_id.to_string(),
            address: address.to_string(),
            user,
            domain,
            display_name: None,
            nickname: None,
        };
        data.contacts.insert(address.to_string(), contact.clone());
        drop(data);
        self.save()?;
        Ok(contact)
    }

    /// Ensure contact and optionally set / update display name.
    pub fn ensure_contact_with_name(&self, address: &str, name: Option<&str>) -> Result<Contact> {
        let mut contact = self.ensure_contact(address)?;
        if let Some(n) = name {
            if contact.display_name.as_deref() != Some(n) {
                contact.display_name = Some(n.to_string());
                self.data
                    .borrow_mut()
                    .contacts
                    .insert(address.to_string(), contact.clone());
                self.save()?;
            }
        }
        Ok(contact)
    }

    /// Manually add a contact with an optional nickname.
    /// Returns an error if the address is already in the book — use
    /// `set_nickname` to update an existing contact's nickname.
    pub fn add_contact(&self, address: &str, nickname: Option<&str>) -> Result<Contact> {
        let address = address.trim();
        if !address.contains('@') {
            anyhow::bail!("Invalid address — must contain '@': {}", address);
        }
        {
            let data = self.data.borrow();
            if data.contacts.contains_key(address) {
                anyhow::bail!("Contact already exists: {}", address);
            }
        }
        let mut contact = self.ensure_contact(address)?;
        let nick = nickname
            .map(str::trim)
            .filter(|s| !s.is_empty())
            .map(str::to_string);
        if nick.is_some() {
            contact.nickname = nick;
            self.data
                .borrow_mut()
                .contacts
                .insert(address.to_string(), contact.clone());
            self.save()?;
        }
        Ok(contact)
    }

    /// Remove a contact from the address book.
    /// Existing messages still reference the address as a plain string — they
    /// are not affected.
    pub fn delete_contact(&self, address: &str) -> Result<()> {
        let removed = self.data.borrow_mut().contacts.remove(address).is_some();
        if !removed {
            anyhow::bail!("Contact not found: {}", address);
        }
        self.save()
    }

    /// Set or clear the nickname for an existing contact.
    /// Pass an empty string to clear the nickname.
    pub fn set_nickname(&self, address: &str, nickname: &str) -> Result<()> {
        let nick = nickname.trim();
        let mut data = self.data.borrow_mut();
        let contact = data
            .contacts
            .get_mut(address)
            .with_context(|| format!("Contact not found: {}", address))?;
        contact.nickname = if nick.is_empty() { None } else { Some(nick.to_string()) };
        drop(data);
        self.save()
    }

    /// Find a contact's full address by its nickname (case-insensitive exact match).
    pub fn find_by_nickname(&self, nickname: &str) -> Option<String> {
        let needle = nickname.trim().to_lowercase();
        self.data
            .borrow()
            .contacts
            .values()
            .find(|c| {
                c.nickname
                    .as_deref()
                    .map(|n| n.to_lowercase() == needle)
                    .unwrap_or(false)
            })
            .map(|c| c.address.clone())
    }

    pub fn resolve_contact_id(&self, id: &str) -> Result<String> {
        self.data
            .borrow()
            .contacts
            .values()
            .find(|c| c.id == id)
            .map(|c| c.address.clone())
            .with_context(|| format!("No contact with ID {}", id))
    }

    pub fn all_contacts(&self) -> Vec<Contact> {
        let mut v: Vec<Contact> = self.data.borrow().contacts.values().cloned().collect();
        v.sort_by(|a, b| {
            a.id.parse::<u64>()
                .unwrap_or(0)
                .cmp(&b.id.parse::<u64>().unwrap_or(0))
        });
        v
    }

    // ── Message Operations ───────────────────────────────────────────────────

    pub fn record_sent(&self, to: &str, body: &str, attachments: Vec<Attachment>) -> Result<()> {
        // Auto-register recipient
        self.ensure_contact(to)?;
        let msg = Message {
            id: Uuid::new_v4().to_string(),
            from: String::new(),
            to: to.to_string(),
            body: body.to_string(),
            timestamp: Local::now(),
            read: true,
            starred: false,
            folder: Folder::Sent,
            uid: None,
            message_id: None,
            attachments,
        };
        self.data.borrow_mut().messages.push(msg);
        self.save()
    }

    /// Called by the IMAP sync to store an incoming message.
    /// Auto-registers the sender as a contact.
    /// Returns false (without storing) if the message-id is already known.
    pub fn deliver(
        &self,
        from: &str,
        body: &str,
        display_name: Option<&str>,
        uid: Option<u32>,
        message_id: Option<String>,
        attachments: Vec<Attachment>,
    ) -> Result<bool> {
        // Deduplicate: skip if we already have this message-id.
        if let Some(ref mid) = message_id {
            if self.has_message_id(mid) {
                return Ok(false);
            }
        }
        self.ensure_contact_with_name(from, display_name)?;
        let msg = Message {
            id: Uuid::new_v4().to_string(),
            from: from.to_string(),
            to: String::new(),
            body: body.to_string(),
            timestamp: Local::now(),
            read: false,
            starred: false,
            folder: Folder::Inbox,
            uid,
            message_id,
            attachments,
        };
        self.data.borrow_mut().messages.push(msg);
        self.save()?;
        Ok(true)
    }

    /// Returns true if any stored message already carries this RFC 2822 Message-ID.
    pub fn has_message_id(&self, mid: &str) -> bool {
        self.data
            .borrow()
            .messages
            .iter()
            .any(|m| m.message_id.as_deref() == Some(mid))
    }

    pub fn messages_in(&self, folder: &Folder) -> Vec<(usize, Message)> {
        self.data
            .borrow()
            .messages
            .iter()
            .enumerate()
            .filter(|(_, m)| {
                if folder == &Folder::Starred {
                    m.starred
                } else {
                    &m.folder == folder
                }
            })
            .map(|(i, m)| (i, m.clone()))
            .collect()
    }

    pub fn get_message(&self, index: usize) -> Option<Message> {
        self.data.borrow().messages.get(index).cloned()
    }

    pub fn mark_read(&self, index: usize) -> Result<()> {
        if let Some(m) = self.data.borrow_mut().messages.get_mut(index) {
            m.read = true;
        }
        self.save()
    }

    pub fn toggle_star(&self, index: usize) -> Result<()> {
        if let Some(m) = self.data.borrow_mut().messages.get_mut(index) {
            m.starred = !m.starred;
        }
        self.save()
    }

    pub fn move_to_trash(&self, index: usize) -> Result<()> {
        if let Some(m) = self.data.borrow_mut().messages.get_mut(index) {
            m.folder = Folder::Trash;
        }
        self.save()
    }

    pub fn unread_count(&self) -> usize {
        self.data
            .borrow()
            .messages
            .iter()
            .filter(|m| !m.read && m.folder == Folder::Inbox)
            .count()
    }

    pub fn unread_in(&self, folder: &Folder) -> usize {
        self.data
            .borrow()
            .messages
            .iter()
            .filter(|m| !m.read && &m.folder == folder)
            .count()
    }
}

// ─── Helpers ──────────────────────────────────────────────────────────────────

/// Heuristic: does this string look like an undecoded MIME body?
/// Checks for a MIME boundary line (--<hex-string>) or a Content-Type header
/// embedded in the body text.
fn looks_like_raw_mime(body: &str) -> bool {
    body.contains("Content-Type:") || body.contains("Content-Transfer-Encoding:")
}

fn split_address(addr: &str) -> (String, String) {
    if let Some(at) = addr.rfind('@') {
        (addr[..at].to_string(), addr[at + 1..].to_string())
    } else {
        (addr.to_string(), "unknown".to_string())
    }
}