use crate::util::{validate_not_empty_payload, validate_not_empty_str};
use appflowy_ai_client::dto::AIModel;
use bytes::Bytes;
use chrono::{DateTime, Utc};
use collab_entity::CollabType;
use serde::{Deserialize, Serialize};
use serde_repr::{Deserialize_repr, Serialize_repr};
use std::cmp::Ordering;
use std::collections::HashMap;
use std::fmt::Display;
use std::ops::{Deref, DerefMut};
use std::str::FromStr;
use tracing::error;
use uuid::Uuid;
use validator::Validate;

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct CreateCollabParams {
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,

  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,

  #[validate(custom = "validate_not_empty_payload")]
  pub encoded_collab_v1: Vec<u8>,

  pub collab_type: CollabType,
}

impl From<(String, CollabParams)> for CreateCollabParams {
  fn from((workspace_id, collab_params): (String, CollabParams)) -> Self {
    Self {
      workspace_id,
      object_id: collab_params.object_id,
      encoded_collab_v1: collab_params.encoded_collab_v1.to_vec(),
      collab_type: collab_params.collab_type,
    }
  }
}

impl CreateCollabParams {
  pub fn split(self) -> (CollabParams, String) {
    (
      CollabParams {
        object_id: self.object_id,
        encoded_collab_v1: Bytes::from(self.encoded_collab_v1),
        collab_type: self.collab_type,
        embeddings: None,
      },
      self.workspace_id,
    )
  }

  pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
    bincode::serialize(self)
  }
  pub fn from_bytes(bytes: &[u8]) -> Result<Self, bincode::Error> {
    bincode::deserialize(bytes)
  }
}

pub struct CollabIndexParams {}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct CollabParams {
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
  #[validate(custom = "validate_not_empty_payload")]
  pub encoded_collab_v1: Bytes,
  pub collab_type: CollabType,
  #[serde(default)]
  pub embeddings: Option<AFCollabEmbeddings>,
}

impl CollabParams {
  pub fn new<T: ToString>(
    object_id: T,
    collab_type: CollabType,
    encoded_collab_v1: Vec<u8>,
  ) -> Self {
    let object_id = object_id.to_string();
    Self {
      object_id,
      collab_type,
      encoded_collab_v1: Bytes::from(encoded_collab_v1),
      embeddings: None,
    }
  }

  pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
    bincode::serialize(self)
  }

  pub fn from_bytes(bytes: &[u8]) -> Result<Self, bincode::Error> {
    match bincode::deserialize(bytes) {
      Ok(value) => Ok(value),
      Err(_) => {
        // fallback to deserialize into older version
        let old: CollabParamsV0 = bincode::deserialize(bytes)?;
        Ok(Self {
          object_id: old.object_id,
          encoded_collab_v1: old.encoded_collab_v1.into(),
          collab_type: old.collab_type,
          embeddings: None,
        })
      },
    }
  }
}
#[derive(Serialize, Deserialize)]
struct CollabParamsV0 {
  object_id: String,
  encoded_collab_v1: Vec<u8>,
  collab_type: CollabType,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct BatchCreateCollabParams {
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,
  pub params_list: Vec<CollabParams>,
}

impl BatchCreateCollabParams {
  pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
    bincode::serialize(self)
  }

  pub fn from_bytes(bytes: &[u8]) -> Result<Self, bincode::Error> {
    bincode::deserialize(bytes)
  }
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct DeleteCollabParams {
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct InsertSnapshotParams {
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
  #[validate(custom = "validate_not_empty_payload")]
  pub encoded_collab_v1: Vec<u8>,
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,
  pub collab_type: CollabType,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SnapshotData {
  pub object_id: String,
  pub encoded_collab_v1: Vec<u8>,
  pub workspace_id: String,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct QuerySnapshotParams {
  pub snapshot_id: i64,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct QueryCollabParams {
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,

  #[serde(flatten)]
  #[validate]
  pub inner: QueryCollab,
}

impl Display for QueryCollabParams {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(
      f,
      "workspace_id: {}, object_id: {}, collab_type: {:?}",
      self.workspace_id, self.object_id, self.collab_type
    )
  }
}

impl QueryCollabParams {
  pub fn new<T1: ToString, T2: ToString>(
    object_id: T1,
    collab_type: CollabType,
    workspace_id: T2,
  ) -> Self {
    let workspace_id = workspace_id.to_string();
    let object_id = object_id.to_string();
    let inner = QueryCollab {
      object_id,
      collab_type,
    };
    Self {
      workspace_id,
      inner,
    }
  }
}

impl Deref for QueryCollabParams {
  type Target = QueryCollab;

  fn deref(&self) -> &Self::Target {
    &self.inner
  }
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct QueryCollab {
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
  pub collab_type: CollabType,
}
impl QueryCollab {
  pub fn new<T: ToString>(object_id: T, collab_type: CollabType) -> Self {
    let object_id = object_id.to_string();
    Self {
      object_id,
      collab_type,
    }
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchQueryCollabParams(pub Vec<QueryCollab>);

impl Deref for BatchQueryCollabParams {
  type Target = Vec<QueryCollab>;

  fn deref(&self) -> &Self::Target {
    &self.0
  }
}

impl DerefMut for BatchQueryCollabParams {
  fn deref_mut(&mut self) -> &mut Self::Target {
    &mut self.0
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AFSnapshotMeta {
  pub snapshot_id: i64,
  pub object_id: String,
  pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AFSnapshotMetas(pub Vec<AFSnapshotMeta>);

#[derive(Debug, Clone, Deserialize)]
pub struct QueryObjectSnapshotParams {
  pub object_id: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AFBlobRecord {
  pub file_id: String,
}

impl AFBlobRecord {
  pub fn new(file_id: String) -> Self {
    Self { file_id }
  }
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub enum QueryCollabResult {
  Success { encode_collab_v1: Vec<u8> },
  Failed { error: String },
}

#[derive(Serialize, Deserialize)]
pub struct BatchQueryCollabResult(pub HashMap<String, QueryCollabResult>);

#[derive(Serialize, Deserialize)]
pub struct WorkspaceUsage {
  pub total_document_size: i64,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct InsertCollabMemberParams {
  pub uid: i64,
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
  pub access_level: AFAccessLevel,
}

pub type UpdateCollabMemberParams = InsertCollabMemberParams;

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct CollabMemberIdentify {
  pub uid: i64,
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
}

#[derive(Serialize, Deserialize)]
pub struct UpdatePublishNamespace {
  pub new_namespace: String,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct QueryCollabMembers {
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,
  #[validate(custom = "validate_not_empty_str")]
  pub object_id: String,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct QueryWorkspaceMember {
  #[validate(custom = "validate_not_empty_str")]
  pub workspace_id: String,

  pub uid: i64,
}

#[derive(Serialize, Deserialize)]
pub struct AFCollabMember {
  pub uid: i64,
  pub oid: String,
  pub permission: AFPermission,
}

#[derive(Serialize, Deserialize)]
pub struct PublishInfo {
  pub namespace: Option<String>,
  pub publish_name: String,
  pub view_id: Uuid,
}

#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]
#[repr(i32)]
pub enum AFRole {
  Owner = 1,
  Member = 2,
  Guest = 3,
}

impl AFRole {
  /// The user can create a [Collab] if the user is [AFRole::Owner] or [AFRole::Member] of the workspace.
  pub fn can_create_collab(&self) -> bool {
    matches!(self, AFRole::Owner | AFRole::Member)
  }
}

impl From<i32> for AFRole {
  fn from(value: i32) -> Self {
    // Can't modify the value of the enum
    match value {
      1 => AFRole::Owner,
      2 => AFRole::Member,
      3 => AFRole::Guest,
      _ => {
        error!("Invalid role id: {}", value);
        AFRole::Guest
      },
    }
  }
}

impl From<&str> for AFRole {
  fn from(value: &str) -> Self {
    match i32::from_str(value) {
      Ok(value) => value.into(),
      Err(_) => AFRole::Guest,
    }
  }
}

impl From<AFRole> for i32 {
  fn from(role: AFRole) -> Self {
    role as i32
  }
}

impl From<&AFRole> for i32 {
  fn from(role: &AFRole) -> Self {
    role.clone() as i32
  }
}

impl PartialOrd for AFRole {
  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    Some(self.cmp(other))
  }
}

impl Ord for AFRole {
  fn cmp(&self, other: &Self) -> Ordering {
    let left = i32::from(self);
    let right = i32::from(other);
    // lower value has higher priority
    left.cmp(&right).reverse()
  }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AFPermission {
  /// The permission id
  pub id: i32,
  pub name: String,
  pub access_level: AFAccessLevel,
  pub description: String,
}

#[derive(Deserialize_repr, Serialize_repr, Eq, PartialEq, Debug, Clone, Copy)]
#[repr(i32)]
pub enum AFAccessLevel {
  // Can't modify the value of the enum
  ReadOnly = 10,
  ReadAndComment = 20,
  ReadAndWrite = 30,
  FullAccess = 50,
}

impl AFAccessLevel {
  pub fn can_write(&self) -> bool {
    match self {
      AFAccessLevel::ReadOnly | AFAccessLevel::ReadAndComment => false,
      AFAccessLevel::ReadAndWrite | AFAccessLevel::FullAccess => true,
    }
  }

  pub fn can_delete(&self) -> bool {
    match self {
      AFAccessLevel::ReadOnly | AFAccessLevel::ReadAndComment | AFAccessLevel::ReadAndWrite => {
        false
      },
      AFAccessLevel::FullAccess => true,
    }
  }
}

impl From<&AFRole> for AFAccessLevel {
  fn from(value: &AFRole) -> Self {
    match value {
      AFRole::Owner => AFAccessLevel::FullAccess,
      AFRole::Member => AFAccessLevel::ReadAndWrite,
      AFRole::Guest => AFAccessLevel::ReadOnly,
    }
  }
}

impl From<i32> for AFAccessLevel {
  fn from(value: i32) -> Self {
    // Can't modify the value of the enum
    match value {
      10 => AFAccessLevel::ReadOnly,
      20 => AFAccessLevel::ReadAndComment,
      30 => AFAccessLevel::ReadAndWrite,
      50 => AFAccessLevel::FullAccess,
      _ => {
        error!("Invalid access level: {}", value);
        AFAccessLevel::ReadOnly
      },
    }
  }
}

impl From<&str> for AFAccessLevel {
  fn from(value: &str) -> Self {
    match i32::from_str(value) {
      Ok(value) => AFAccessLevel::from(value),
      Err(_) => AFAccessLevel::ReadOnly,
    }
  }
}

impl From<AFAccessLevel> for i32 {
  fn from(level: AFAccessLevel) -> Self {
    level as i32
  }
}

impl From<&AFAccessLevel> for i32 {
  fn from(level: &AFAccessLevel) -> Self {
    *level as i32
  }
}

impl PartialOrd for AFAccessLevel {
  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    Some(self.cmp(other))
  }
}

impl Ord for AFAccessLevel {
  fn cmp(&self, other: &Self) -> Ordering {
    let left = i32::from(self);
    let right = i32::from(other);
    left.cmp(&right)
  }
}

#[derive(Serialize, Deserialize)]
pub struct AFCollabMembers(pub Vec<AFCollabMember>);

pub type RawData = Vec<u8>;

#[derive(Serialize, Deserialize)]
pub struct AFUserProfile {
  pub uid: i64,
  pub uuid: Uuid,
  pub email: Option<String>,
  pub password: Option<String>,
  pub name: Option<String>,
  pub metadata: Option<serde_json::Value>,
  pub encryption_sign: Option<String>,
  pub latest_workspace_id: Uuid,
  pub updated_at: i64,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct AFWorkspace {
  pub workspace_id: Uuid,
  pub database_storage_id: Uuid,
  pub owner_uid: i64,
  pub owner_name: String,
  pub workspace_type: i32,
  pub workspace_name: String,
  pub created_at: DateTime<Utc>,
  pub icon: String,
  pub member_count: Option<i64>,
}

#[derive(Serialize, Deserialize)]
pub struct AFWorkspaceSettings {
  #[serde(default)]
  pub disable_search_indexing: bool,

  #[serde(default)]
  pub ai_model: String,
}

impl Default for AFWorkspaceSettings {
  fn default() -> Self {
    Self {
      disable_search_indexing: false,
      ai_model: "".to_string(),
    }
  }
}

#[derive(Default, Serialize, Deserialize, Debug)]
pub struct AFWorkspaceSettingsChange {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub disable_search_indexing: Option<bool>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub ai_model: Option<String>,
}

impl AFWorkspaceSettingsChange {
  pub fn new() -> Self {
    Self {
      disable_search_indexing: None,
      ai_model: None,
    }
  }
  pub fn disable_search_indexing(mut self, disable_search_indexing: bool) -> Self {
    self.disable_search_indexing = Some(disable_search_indexing);
    self
  }
  pub fn ai_model(mut self, ai_model: String) -> Self {
    self.ai_model = Some(ai_model);
    self
  }
}

#[derive(Serialize, Deserialize)]
pub struct AFUserWorkspaceInfo {
  pub user_profile: AFUserProfile,
  pub visiting_workspace: AFWorkspace,
  pub workspaces: Vec<AFWorkspace>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Hash, Eq, PartialEq)]
pub struct AFWorkspaceMember {
  pub name: String,
  pub email: String,
  pub role: AFRole,
  pub avatar_url: Option<String>,
}

#[derive(Deserialize, Serialize, Debug)]
pub struct AFWorkspaceInvitation {
  pub invite_id: Uuid,
  pub workspace_id: Uuid,
  pub workspace_name: Option<String>,
  pub inviter_email: Option<String>,
  pub inviter_name: Option<String>,
  pub status: AFWorkspaceInvitationStatus,
  pub updated_at: DateTime<Utc>,
}

#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone)]
#[repr(i16)]
pub enum AFWorkspaceInvitationStatus {
  Pending = 0,
  Accepted = 1,
  Rejected = 2,
}

impl From<i16> for AFWorkspaceInvitationStatus {
  fn from(value: i16) -> Self {
    match value {
      0 => AFWorkspaceInvitationStatus::Pending,
      1 => AFWorkspaceInvitationStatus::Accepted,
      2 => AFWorkspaceInvitationStatus::Rejected,
      _ => {
        error!("Invalid role id: {}", value);
        AFWorkspaceInvitationStatus::Pending
      },
    }
  }
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct CreateChatParams {
  #[validate(custom = "validate_not_empty_str")]
  pub chat_id: String,
  pub name: String,
  pub rag_ids: Vec<String>,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct UpdateChatParams {
  #[validate(custom = "validate_not_empty_str")]
  pub chat_id: String,

  #[validate(custom = "validate_not_empty_str")]
  pub name: Option<String>,

  pub metadata: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct CreateChatMessageParams {
  #[validate(custom = "validate_not_empty_str")]
  pub content: String,
  pub message_type: ChatMessageType,

  /// metadata is json array object
  #[serde(skip_serializing_if = "Option::is_none")]
  pub metadata: Option<serde_json::Value>,
}

/// [ChatMessageMetadata] is used when creating a new question message.
/// All the properties of [ChatMessageMetadata] except [ChatMetadataData] will be stored as a
/// metadata for specific [ChatMessage]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessageMetadata {
  pub data: ChatMetadataData,
  /// The id for the metadata. It can be a file_id, view_id
  pub id: String,
  /// The name for the metadata. For example, @xxx, @xx.txt
  pub name: String,
  pub source: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub extract: Option<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMetadataData {
  /// The textual content of the metadata. This field can contain raw text data from a specific
  /// document or any other text content that is indexable. This content is typically used for
  /// search and indexing purposes within the chat context.
  pub content: String,

  /// The type of content represented by this metadata. This could indicate the format or
  /// nature of the content (e.g., text, markdown, PDF). The `content_type` helps in
  /// processing or rendering the content appropriately.
  pub content_type: ChatMetadataContentType,

  /// The size of the content in bytes.
  pub size: i64,
}

impl ChatMetadataData {
  /// Validates the `ChatMetadataData` instance.
  ///
  /// This method checks the validity of the data based on the content type and the presence of content or URL.
  /// - If `content` is empty, the method checks if `url` is provided. If `url` is also empty, the data is invalid.
  /// - For `Text` and `Markdown`, it ensures that the content length matches the specified size if content is present.
  /// - For `Unknown` and `PDF`, it currently returns `false` as these types are either unsupported or
  ///   require additional validation logic.
  ///
  /// Returns `true` if the data is valid according to its content type and the presence of content or URL, otherwise `false`.
  pub fn validate(&self) -> Result<(), anyhow::Error> {
    match self.content_type {
      ChatMetadataContentType::Text | ChatMetadataContentType::Markdown => {
        if self.content.len() != self.size as usize {
          return Err(anyhow::anyhow!(
            "Invalid content size: content size: {}, expected size: {}",
            self.content.len(),
            self.size
          ));
        }
      },
      ChatMetadataContentType::PDF => {
        if self.content.is_empty() {
          return Err(anyhow::anyhow!("Invalid content: content is empty"));
        }
      },
      ChatMetadataContentType::Unknown => {
        return Err(anyhow::anyhow!(
          "Unsupported content type: {:?}",
          self.content_type
        ));
      },
    }
    Ok(())
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ChatMetadataContentType {
  Unknown,
  Text,
  Markdown,
  PDF,
}

impl Display for ChatMetadataContentType {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    match self {
      ChatMetadataContentType::Unknown => write!(f, "unknown"),
      ChatMetadataContentType::Text => write!(f, "text"),
      ChatMetadataContentType::Markdown => write!(f, "markdown"),
      ChatMetadataContentType::PDF => write!(f, "pdf"),
    }
  }
}

impl ChatMetadataData {
  pub fn new_text(content: String) -> Self {
    let size = content.len();
    Self {
      content,
      content_type: ChatMetadataContentType::Text,
      size: size as i64,
    }
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateChatMessageMetaParams {
  pub message_id: i64,
  pub meta_data: HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateChatMessageContentParams {
  pub chat_id: String,
  pub message_id: i64,
  pub content: String,
  #[serde(default)]
  pub model: AIModel,
}

#[derive(Debug, Clone, Default, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum ChatMessageType {
  System = 0,
  #[default]
  User = 1,
}

impl CreateChatMessageParams {
  pub fn new_system<T: ToString>(content: T) -> Self {
    Self {
      content: content.to_string(),
      message_type: ChatMessageType::System,
      metadata: None,
    }
  }

  pub fn new_user<T: ToString>(content: T) -> Self {
    Self {
      content: content.to_string(),
      message_type: ChatMessageType::User,
      metadata: None,
    }
  }

  pub fn with_metadata(mut self, metadata: serde_json::Value) -> Self {
    self.metadata = Some(metadata);
    self
  }
}
#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct GetChatMessageParams {
  pub cursor: MessageCursor,
  pub limit: u64,
}

impl GetChatMessageParams {
  pub fn offset(offset: u64, limit: u64) -> Self {
    Self {
      cursor: MessageCursor::Offset(offset),
      limit,
    }
  }

  pub fn after_message_id(after_message_id: i64, limit: u64) -> Self {
    Self {
      cursor: MessageCursor::AfterMessageId(after_message_id),
      limit,
    }
  }
  pub fn before_message_id(before_message_id: i64, limit: u64) -> Self {
    Self {
      cursor: MessageCursor::BeforeMessageId(before_message_id),
      limit,
    }
  }

  pub fn next_back(limit: u64) -> Self {
    Self {
      cursor: MessageCursor::NextBack,
      limit,
    }
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageCursor {
  Offset(u64),
  AfterMessageId(i64),
  BeforeMessageId(i64),
  NextBack,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessage {
  pub author: ChatAuthor,
  pub message_id: i64,
  pub content: String,
  pub created_at: DateTime<Utc>,
  pub meta_data: serde_json::Value,
  pub reply_message_id: Option<i64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QAChatMessage {
  pub question: ChatMessage,
  pub answer: Option<ChatMessage>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RepeatedChatMessage {
  pub messages: Vec<ChatMessage>,
  pub has_more: bool,
  pub total: i64,
}

#[derive(Debug, Default, Clone, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum ChatAuthorType {
  Unknown = 0,
  Human = 1,
  #[default]
  System = 2,
  AI = 3,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatAuthor {
  pub author_id: i64,
  #[serde(default)]
  pub author_type: ChatAuthorType,
  #[serde(default)]
  #[serde(skip_serializing_if = "Option::is_none")]
  pub meta: Option<serde_json::Value>,
}

impl ChatAuthor {
  pub fn new(author_id: i64, author_type: ChatAuthorType) -> Self {
    Self {
      author_id,
      author_type,
      meta: None,
    }
  }

  pub fn ai() -> Self {
    Self {
      author_id: 0,
      author_type: ChatAuthorType::AI,
      meta: None,
    }
  }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AFCollabEmbeddingParams {
  pub fragment_id: String,
  pub object_id: String,
  pub collab_type: CollabType,
  pub content_type: EmbeddingContentType,
  pub content: String,
  pub embedding: Option<Vec<f32>>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AFCollabEmbeddings {
  pub tokens_consumed: u32,
  pub params: Vec<AFCollabEmbeddingParams>,
}

/// Type of content stored by the embedding.
/// Currently only plain text of the document is supported.
/// In the future, we might support other kinds like i.e. PDF, images or image-extracted text.
#[repr(i32)]
#[derive(Debug, Copy, Clone, Serialize_repr, Deserialize_repr, Eq, PartialEq)]
pub enum EmbeddingContentType {
  /// The plain text representation of the document.
  PlainText = 0,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UpdateChatMessageResponse {
  pub answer: Option<ChatMessage>,
}

#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
pub struct CreateAnswerMessageParams {
  #[validate(custom = "validate_not_empty_str")]
  pub content: String,

  #[serde(skip_serializing_if = "Option::is_none")]
  pub metadata: Option<serde_json::Value>,

  pub question_message_id: i64,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct PublishCollabMetadata<Metadata> {
  pub view_id: uuid::Uuid,
  pub publish_name: String,
  pub metadata: Metadata,
}

#[derive(Debug)]
pub struct PublishCollabItem<Meta, Data> {
  pub meta: PublishCollabMetadata<Meta>,
  pub data: Data,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GlobalComments {
  pub comments: Vec<GlobalComment>,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct AFWebUser {
  pub uuid: Uuid,
  pub name: String,
  pub avatar_url: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GlobalComment {
  pub user: Option<AFWebUser>,
  pub created_at: DateTime<Utc>,
  pub last_updated_at: DateTime<Utc>,
  pub content: String,
  pub reply_comment_id: Option<Uuid>,
  pub comment_id: Uuid,
  pub is_deleted: bool,
  pub can_be_deleted: bool,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateGlobalCommentParams {
  pub content: String,
  pub reply_comment_id: Option<Uuid>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct DeleteGlobalCommentParams {
  pub comment_id: Uuid,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Reactions {
  pub reactions: Vec<Reaction>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Reaction {
  pub reaction_type: String,
  pub react_users: Vec<AFWebUser>,
  pub comment_id: Uuid,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetReactionQueryParams {
  pub comment_id: Option<Uuid>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateReactionParams {
  pub reaction_type: String,
  pub comment_id: Uuid,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct DeleteReactionParams {
  pub reaction_type: String,
  pub comment_id: Uuid,
}

/// Indexing status of a document.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum IndexingStatus {
  /// Indexing is disabled for that document.
  Disabled,
  /// Indexing is enabled, but the document has never been indexed.
  NotIndexed,
  /// Indexing is enabled and the document has been indexed.
  Indexed,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateCategories {
  pub categories: Vec<TemplateCategory>,
}

#[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug, Copy, Clone)]
#[repr(i32)]
pub enum TemplateCategoryType {
  UseCase = 0,
  Feature = 1,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateCategory {
  pub id: Uuid,
  pub name: String,
  pub icon: String,
  pub bg_color: String,
  pub description: String,
  pub category_type: TemplateCategoryType,
  pub priority: i32,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateCategoryMinimal {
  pub id: Uuid,
  pub name: String,
  pub icon: String,
  pub bg_color: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateTemplateCategoryParams {
  pub name: String,
  pub icon: String,
  pub bg_color: String,
  pub description: String,
  pub category_type: TemplateCategoryType,
  pub priority: i32,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetTemplateCategoriesQueryParams {
  pub name_contains: Option<String>,
  pub category_type: Option<TemplateCategoryType>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct UpdateTemplateCategoryParams {
  pub name: String,
  pub icon: String,
  pub bg_color: String,
  pub description: String,
  pub category_type: TemplateCategoryType,
  pub priority: i32,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateCreators {
  pub creators: Vec<TemplateCreator>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AccountLink {
  pub link_type: String,
  pub url: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateCreator {
  pub id: Uuid,
  pub name: String,
  pub avatar_url: String,
  pub account_links: Vec<AccountLink>,
  pub number_of_templates: i32,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateCreatorMinimal {
  pub id: Uuid,
  pub name: String,
  pub avatar_url: String,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateTemplateCreatorParams {
  pub name: String,
  pub avatar_url: String,
  pub account_links: Vec<AccountLink>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct UpdateTemplateCreatorParams {
  pub name: String,
  pub avatar_url: String,
  pub account_links: Vec<AccountLink>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetTemplateCreatorsQueryParams {
  pub name_contains: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Template {
  pub view_id: Uuid,
  pub created_at: DateTime<Utc>,
  pub last_updated_at: DateTime<Utc>,
  pub name: String,
  pub description: String,
  pub about: String,
  pub view_url: String,
  pub categories: Vec<TemplateCategory>,
  pub creator: TemplateCreator,
  pub is_new_template: bool,
  pub is_featured: bool,
  pub related_templates: Vec<TemplateMinimal>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateMinimal {
  pub view_id: Uuid,
  pub created_at: DateTime<Utc>,
  pub last_updated_at: DateTime<Utc>,
  pub name: String,
  pub description: String,
  pub view_url: String,
  pub creator: TemplateCreatorMinimal,
  pub categories: Vec<TemplateCategoryMinimal>,
  pub is_new_template: bool,
  pub is_featured: bool,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Templates {
  pub templates: Vec<TemplateMinimal>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CreateTemplateParams {
  pub view_id: Uuid,
  pub name: String,
  pub description: String,
  pub about: String,
  pub view_url: String,
  pub category_ids: Vec<Uuid>,
  pub creator_id: Uuid,
  pub is_new_template: bool,
  pub is_featured: bool,
  pub related_view_ids: Vec<Uuid>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct UpdateTemplateParams {
  pub name: String,
  pub description: String,
  pub about: String,
  pub view_url: String,
  pub category_ids: Vec<Uuid>,
  pub creator_id: Uuid,
  pub is_new_template: bool,
  pub is_featured: bool,
  pub related_view_ids: Vec<Uuid>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct GetTemplatesQueryParams {
  pub category_id: Option<Uuid>,
  pub is_featured: Option<bool>,
  pub is_new_template: Option<bool>,
  pub name_contains: Option<String>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateGroup {
  pub category: TemplateCategoryMinimal,
  pub templates: Vec<TemplateMinimal>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateHomePage {
  pub featured_templates: Vec<TemplateMinimal>,
  pub new_templates: Vec<TemplateMinimal>,
  pub template_groups: Vec<TemplateGroup>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct TemplateHomePageQueryParams {
  pub per_count: Option<i64>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct AvatarImageSource {
  pub file_id: String,
}

#[cfg(test)]
mod test {
  use crate::dto::{CollabParams, CollabParamsV0};
  use collab_entity::CollabType;
  use uuid::Uuid;

  #[test]
  fn collab_params_serialization_from_old_format() {
    let v0 = CollabParamsV0 {
      object_id: Uuid::new_v4().to_string(),
      collab_type: CollabType::Document,
      encoded_collab_v1: vec![
        7, 0, 0, 0, 0, 0, 0, 0, 1, 209, 196, 206, 243, 15, 1, 26, 4, 0, 0, 0, 0, 0, 0, 1, 1, 209,
        196, 206, 243, 15, 0, 40, 1, 4, 100, 97, 116, 97, 5, 116, 105, 116, 108, 101, 1, 119, 128,
        8, 120, 118, 88, 114, 83, 79, 105, 70, 69, 84, 70, 97, 66, 79, 57, 53, 111, 122, 87, 110,
        54, 106, 71, 87, 66, 104, 120, 114, 79, 70, 74, 111, 109, 119, 68, 119, 114, 114, 89, 66,
        103, 79, 72, 114, 102, 51, 87, 55, 79, 76, 110, 85, 120, 69, 113, 121, 104, 121, 107, 82,
        117, 82, 113, 73, 104, 89, 72, 84, 114, 105, 122, 56, 122, 72, 90, 67, 110, 97, 120, 83,
        114, 85, 113, 71, 98, 52, 50, 110, 87, 116, 105, 55, 107, 82, 103, 72, 68, 101, 89, 118,
        82, 112, 114, 73, 122, 87, 76, 68, 120, 101, 57, 55, 87, 68, 77, 113, 107, 120, 104, 65,
        71, 103, 48, 51, 49, 110, 119, 111, 106, 70, 108, 114, 102, 83, 99, 89, 110, 73, 50, 98,
        118, 54, 68, 88, 111, 118, 74, 107, 121, 119, 103, 102, 98, 107, 51, 78, 99, 103, 51, 73,
        78, 106, 67, 85, 97, 54, 114, 50, 103, 83, 55, 70, 57, 122, 106, 115, 103, 121, 88, 68, 97,
        101, 50, 68, 84, 70, 84, 72, 87, 112, 105, 102, 71, 108, 52, 48, 114, 106, 113, 56, 119,
        110, 86, 71, 54, 65, 99, 99, 109, 85, 107, 105, 89, 86, 100, 77, 75, 69, 73, 54, 107, 122,
        48, 80, 54, 50, 99, 80, 100, 115, 78, 90, 49, 70, 90, 106, 117, 106, 98, 111, 88, 65, 105,
        83, 108, 82, 105, 90, 73, 73, 90, 102, 116, 77, 117, 79, 81, 79, 85, 53, 71, 72, 65, 49,
        119, 118, 88, 97, 98, 122, 52, 122, 77, 70, 85, 112, 100, 115, 67, 89, 107, 114, 88, 87,
        101, 65, 79, 86, 102, 77, 102, 106, 100, 117, 74, 57, 89, 82, 65, 103, 72, 100, 120, 89,
        75, 54, 103, 70, 89, 122, 75, 122, 53, 119, 78, 76, 83, 68, 90, 101, 115, 109, 116, 117,
        65, 54, 53, 48, 97, 52, 85, 51, 57, 111, 74, 90, 73, 77, 117, 105, 80, 116, 57, 70, 84,
        118, 76, 122, 111, 82, 116, 68, 51, 83, 71, 108, 78, 77, 71, 102, 68, 84, 110, 114, 80,
        106, 79, 65, 75, 114, 118, 116, 98, 57, 72, 84, 108, 101, 76, 109, 48, 110, 54, 102, 97,
        83, 89, 77, 66, 88, 69, 119, 78, 71, 89, 75, 53, 114, 80, 56, 72, 55, 122, 112, 116, 82,
        52, 117, 121, 113, 67, 53, 72, 48, 101, 83, 81, 76, 76, 87, 110, 53, 81, 106, 67, 100, 103,
        55, 85, 109, 115, 103, 55, 110, 121, 87, 121, 117, 98, 72, 121, 85, 106, 57, 66, 90, 89,
        54, 50, 122, 84, 69, 103, 57, 52, 67, 102, 50, 82, 114, 74, 84, 115, 87, 97, 87, 113, 109,
        88, 105, 113, 97, 100, 113, 57, 87, 114, 70, 57, 120, 108, 80, 122, 52, 113, 119, 53, 48,
        69, 73, 78, 90, 55, 120, 65, 67, 122, 89, 111, 84, 57, 88, 79, 112, 105, 76, 76, 51, 77,
        52, 119, 84, 98, 67, 54, 101, 105, 89, 72, 80, 99, 119, 90, 109, 56, 105, 49, 68, 57, 102,
        111, 75, 65, 68, 74, 87, 106, 69, 65, 85, 71, 104, 85, 75, 117, 66, 70, 105, 72, 100, 75,
        121, 86, 74, 81, 56, 49, 73, 82, 85, 98, 120, 122, 74, 88, 107, 116, 110, 73, 101, 75, 87,
        57, 76, 53, 120, 100, 117, 112, 99, 72, 49, 105, 122, 115, 113, 103, 109, 85, 122, 113, 50,
        70, 76, 118, 76, 121, 88, 55, 110, 84, 78, 120, 99, 78, 70, 122, 117, 66, 98, 65, 75, 112,
        50, 116, 112, 84, 73, 113, 106, 77, 106, 68, 114, 99, 76, 78, 53, 109, 117, 66, 88, 100,
        68, 76, 77, 113, 67, 101, 108, 120, 49, 117, 50, 56, 89, 118, 88, 82, 74, 55, 99, 111, 78,
        77, 77, 87, 111, 121, 50, 52, 73, 116, 120, 73, 81, 72, 53, 107, 70, 50, 111, 67, 97, 122,
        88, 103, 114, 76, 97, 105, 109, 113, 105, 89, 77, 79, 70, 74, 90, 70, 122, 117, 100, 105,
        113, 121, 55, 55, 89, 49, 85, 51, 103, 120, 98, 79, 80, 121, 66, 57, 73, 98, 114, 70, 100,
        113, 83, 101, 106, 65, 82, 121, 49, 83, 73, 122, 84, 80, 103, 121, 84, 110, 117, 74, 117,
        70, 90, 116, 104, 56, 57, 109, 82, 71, 100, 68, 106, 70, 75, 80, 83, 77, 110, 113, 120,
        102, 68, 119, 118, 109, 84, 113, 77, 79, 119, 112, 114, 107, 118, 85, 78, 65, 104, 106, 98,
        53, 81, 98, 80, 71, 122, 107, 52, 83, 67, 121, 68, 78, 108, 107, 55, 109, 121, 105, 51,
        120, 100, 110, 51, 108, 122, 65, 117, 77, 83, 78, 55, 121, 86, 76, 109, 78, 103, 88, 68,
        75, 48, 81, 101, 120, 112, 69, 78, 86, 88, 116, 78, 48, 97, 105, 55, 116, 79, 104, 118, 86,
        89, 101, 74, 112, 82, 87, 82, 115, 84, 54, 55, 97, 111, 76, 56, 109, 120, 53, 73, 55, 85,
        114, 82, 49, 90, 66, 76, 76, 99, 81, 72, 49, 105, 71, 79, 109, 110, 87, 90, 68, 111, 75,
        108, 116, 86, 81, 103, 109, 112, 120, 100, 52, 70, 79, 111, 121, 57, 111, 76, 65, 111, 83,
        67, 56, 48, 120, 53, 87, 56, 72, 83, 83, 51, 103, 114, 49, 88, 85, 53, 111, 51, 90, 86,
        121, 121, 86, 74, 116, 112, 104, 116, 120, 84, 113, 85, 71, 90, 75, 85, 86, 119, 122, 75,
        49, 122, 78, 101, 118, 82, 54, 90, 55, 72, 114, 53, 84, 72, 115, 102, 104, 48, 103, 48, 99,
        65, 101, 65, 111, 122, 89, 106, 89, 117, 49, 110, 79, 115, 78, 80, 71, 53, 107, 112, 54,
        48, 121, 55, 119, 116, 119, 76, 73, 105, 110, 102, 79, 101, 72, 82, 105, 80, 117, 80, 88,
        70, 84, 51, 53, 98, 108, 74, 84, 121, 112, 76, 76, 98, 119, 102, 80, 122, 51, 120, 53, 54,
        113, 68, 0, 0,
      ],
    };
    let data = bincode::serialize(&v0).unwrap();
    let collab_params = CollabParams::from_bytes(&data).unwrap();
    assert_eq!(collab_params.object_id, v0.object_id);
    assert_eq!(collab_params.collab_type, v0.collab_type);
    assert_eq!(collab_params.encoded_collab_v1, v0.encoded_collab_v1);
  }
}