use rocketmq_model::common::message::message_ext::MessageExt;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default)]
pub struct EventProperties {
    pub user_id: Option<String>,
    pub org_id: Option<String>,
    pub request_id: Option<String>,
    pub repo_id: Option<String>,
    pub repo_name: Option<String>,
    pub room_id: Option<String>,
    pub message_id: Option<String>,
    pub thread_id: Option<String>,
    pub issue_id: Option<String>,
    pub pull_id: Option<String>,
    pub timestamp: Option<i64>,
}

impl EventProperties {
    pub fn normalize(&mut self) -> Result<(), String> {
        for id in [
            &mut self.org_id,
            &mut self.repo_id,
            &mut self.room_id,
            &mut self.message_id,
            &mut self.thread_id,
            &mut self.issue_id,
            &mut self.pull_id,
        ]
        .into_iter()
        .flatten()
        {
            *id = uuid::Uuid::parse_str(id)
                .map_err(|_| "resource IDs must be UUIDs")?
                .to_string();
        }
        if let Some(user) = &mut self.user_id {
            let id = user.parse::<i64>().map_err(|_| "invalid user id")?;
            if id <= 0 {
                return Err("user id must be positive".to_string());
            }
            *user = id.to_string();
        }
        Ok(())
    }
    pub(super) fn from_message(message: &MessageExt) -> Self {
        let properties = message.properties();
        Self {
            user_id: properties.get("user").map(ToString::to_string),
            org_id: properties.get("org").map(ToString::to_string),
            request_id: properties.get("request_id").map(ToString::to_string),
            repo_id: properties.get("repo_id").map(ToString::to_string),
            repo_name: properties.get("repo_name").map(ToString::to_string),
            room_id: properties.get("room_id").map(ToString::to_string),
            message_id: properties.get("message_id").map(ToString::to_string),
            thread_id: properties.get("thread_id").map(ToString::to_string),
            issue_id: properties.get("issue_id").map(ToString::to_string),
            pull_id: properties.get("pull_id").map(ToString::to_string),
            timestamp: properties
                .get("timestamp")
                .and_then(|value| value.as_str().parse().ok()),
        }
    }

    pub fn is_empty(&self) -> bool {
        self.user_id.is_none()
            && self.org_id.is_none()
            && self.request_id.is_none()
            && self.repo_id.is_none()
            && self.repo_name.is_none()
            && self.room_id.is_none()
            && self.message_id.is_none()
            && self.thread_id.is_none()
            && self.issue_id.is_none()
            && self.pull_id.is_none()
            && self.timestamp.is_none()
    }

    pub fn matches(&self, event: &Self) -> bool {
        if self.is_empty() {
            return false;
        }

        matches_field(&self.user_id, &event.user_id)
            && matches_field(&self.org_id, &event.org_id)
            && matches_field(&self.request_id, &event.request_id)
            && matches_field(&self.repo_id, &event.repo_id)
            && matches_field(&self.repo_name, &event.repo_name)
            && matches_field(&self.room_id, &event.room_id)
            && matches_field(&self.message_id, &event.message_id)
            && matches_field(&self.thread_id, &event.thread_id)
            && matches_field(&self.issue_id, &event.issue_id)
            && matches_field(&self.pull_id, &event.pull_id)
            && matches_field(&self.timestamp, &event.timestamp)
    }
}

fn matches_field<T: PartialEq>(filter: &Option<T>, value: &Option<T>) -> bool {
    match filter {
        Some(expected) => value.as_ref() == Some(expected),
        None => true,
    }
}