import { request } from '../../../utils';
import { API } from '../../../types';
import { ResponseType } from '../response-type';

export interface PostSearchUsersReturn extends ResponseType {
  data: {
    user_id: number;
    first_name: string;
    last_name: string;
    avatar: string | null;
  }[];
}

// status: 1 -sent; 2 -received; 3 -read; 4 - deleted
export interface PostGetChatsListReturn extends ResponseType {
  conversations: {
    uid: number | null;
    group_chat_token: string | null;
    name: string;
    avatar: string | null;
    short: string;
    sent_by: number;
    updated: Date;
    status: 1 | 2 | 3 | 4;
    unread_count: number;
    last_message_id: number;
    pin: 0 | 1;
    pin_order: number;
    archive: 0 | 1;
    archive_order: number;
    attachement_name: string;
    encrypted: 0 | 1;
    muted: 0 | 1;
    user_type: 'normal' | 'not_exist' | 'blocked';
  }[];
}

interface Attachement {
  id: number;
  filename: string;
  filetype: string;
  attachment_small_url?: string;
  attachment_full_url?: string;
  lat?: number;
  lng?: number;
  attachment_link?: string;
}

interface Message {
  id: number;
  sender: number;
  recipient: number;
  text: string;
  status: 1 | 2 | 3 | 4;
  sent_datetime: Date;
  received_datetime: Date | null;
  read_datetime: Date | null;
  reply_to_id: number;
  reactions: string;
  edits: string;
  attachement: -1 | Attachement;
  encrypted: 0 | 1;
}

export interface PostGetChatWithReturn extends ResponseType {
  messages: (Message & {
    reply_to: Message;
  })[];
}

export interface PostSendMessage {
  token: string;
  to_uid: number;
  text: string;
  reply_to_id?: number;
  attachment?: { uri: string; type: string; name?: string } | -1;
}

export interface PostSendGroupMessage {
  token: string;
  to_group_token: string;
  text: string;
  reply_to_id?: number;
  attachment?: { uri: string; type: string; name?: string } | -1;
}

export interface PostSendMessageReturn extends ResponseType {
  message_id: number;
  attachment?: any;
}

export interface PostMessagesReceivedOrRead {
  token: string;
  from_user: number;
  messages_id: number[];
}

export interface PostGroupMessagesReceivedOrRead {
  token: string;
  group_token: string;
  messages_id: number[];
}

export interface PostReactToMessage {
  token: string;
  message_id: number;
  reaction: string;
  conversation_with_user: number;
}

export interface PostUnreactToMessage {
  token: string;
  message_id: number;
  conversation_with_user: number;
}

export interface PostReactToGroupMessage {
  token: string;
  message_id: number;
  reaction: string;
  group_token: string;
}

export interface PostUnreactToGroupMessage {
  token: string;
  message_id: number;
  group_token: string;
}

export interface PostDeleteMessage {
  token: string;
  message_id: number;
  conversation_with_user: number;
}

export interface PostDeleteChat {
  token: string;
  conversation_with_user: number;
}

export interface PostReportConversation {
  token: string;
  reported_user_id: number;
}

export interface PostSetSettings {
  token: string;
  value: 0 | 1;
  conversation_with_user: number;
}

export interface PostGetBlockedReturn extends ResponseType {
  blocked: {
    id: number;
    first_name: string;
    last_name: string;
    avatar: string | null;
  }[];
}

export interface PostGetUnreadCountReturn extends ResponseType {
  unread_conversations: number;
}

export interface PostCreateGroup {
  token: string;
  users: number[];
  name: string;
  admins: number[] | [];
  description?: string;
  group_avatar?: { uri: string; type: string; name?: string };
  members_can_edit_settings?: 0 | 1;
  members_can_add_new_members?: 0 | 1;
  members_can_send_messages?: 0 | 1;
}

export const chatApi = {
  searchUsers: (token: string, search: string) =>
    request.postForm<PostSearchUsersReturn>(API.SEARCH_USERS, { token, search }),
  getChatsList: (token: string, archive: 0 | 1) =>
    request.postForm<PostGetChatsListReturn>(API.GET_CHATS_LIST, { token, archive }),
  getChatWith: (
    token: string,
    uid: number,
    no_of_messages: number,
    previous_than_message_id: number
  ) =>
    request.postForm<PostGetChatWithReturn>(API.GET_CHAT_WITH, {
      token,
      uid,
      no_of_messages,
      previous_than_message_id
    }),
  sendMessage: (data: PostSendMessage) => {
    const formData = new FormData();
    formData.append('token', data.token);
    formData.append('to_uid', data.to_uid.toString());
    formData.append('text', data.text);
    if (data.reply_to_id && data.reply_to_id !== undefined) {
      formData.append('reply_to_id', data.reply_to_id.toString());
    }
    if (data.attachment && data.attachment !== -1) {
      const { uri, type, name } = data.attachment;
      formData.append('attachment', {
        uri,
        type: type === 'image' ? type + '/' + uri.split('.').pop()! : type,
        name: name || 'file'
      } as unknown as Blob);
    }

    return request.postForm<PostSendMessageReturn>(API.SEND_MESSAGE, formData);
  },
  messagesReceived: (data: PostMessagesReceivedOrRead) =>
    request.postForm<ResponseType>(API.MESSAGES_RECEIVED, data),
  messagesRead: (data: PostMessagesReceivedOrRead) =>
    request.postForm<ResponseType>(API.MESSAGES_READ, data),
  reactToMessage: (data: PostReactToMessage) =>
    request.postForm<ResponseType>(API.REACT_TO_MESSAGE, data),
  deleteMessage: (data: PostDeleteMessage) =>
    request.postForm<ResponseType>(API.DELETE_MESSAGE, data),
  setPin: (data: PostSetSettings) => request.postForm<ResponseType>(API.SET_PIN, data),
  setArchive: (data: PostSetSettings) => request.postForm<ResponseType>(API.SET_ARCHIVE, data),
  setBlock: (data: PostSetSettings) => request.postForm<ResponseType>(API.SET_BLOCK, data),
  setMute: (data: PostSetSettings) => request.postForm<ResponseType>(API.SET_MUTE, data),
  deleteChat: (data: PostDeleteChat) => request.postForm<ResponseType>(API.DELETE_CHAT, data),
  unreactToMessage: (data: PostUnreactToMessage) =>
    request.postForm<ResponseType>(API.UNREACT_TO_MESSAGE, data),
  getBlocked: (token: string) => request.postForm<PostGetBlockedReturn>(API.GET_BLOCKED, { token }),
  getUnreadMessagesCount: (token: string) =>
    request.postForm<PostGetUnreadCountReturn>(API.GET_UNREAD_MESSAGES_PRESENT, {
      token
    }),
  reportConversation: (data: PostReportConversation) =>
    request.postForm<ResponseType>(API.REPORT_CONVERSATION, data),
  createGroup: (data: PostCreateGroup) => {
    const formData = new FormData();

    formData.append('token', data.token);
    formData.append('users', JSON.stringify(data.users));
    formData.append('name', data.name);

    if (data.description) {
      formData.append('description', data.description);
    }

    formData.append('admins', JSON.stringify(data.admins));

    if (data.group_avatar) {
      const { uri, type, name } = data.group_avatar;
      formData.append('attachment', {
        uri,
        type: type === 'image' ? type + '/' + uri.split('.').pop()! : type,
        name: name || 'file'
      } as unknown as Blob);
    }

    return request.postForm<ResponseType>(API.CREATE_GROUP, formData);
  },
  getGroupChat: (
    token: string,
    group_token: string,
    no_of_messages: number,
    previous_than_message_id: number
  ) =>
    request.postForm<PostGetChatWithReturn>(API.GET_GROUP_CHAT, {
      token,
      group_token,
      no_of_messages,
      previous_than_message_id
    }),
  sendGroupMessage: (data: PostSendGroupMessage) => {
    const formData = new FormData();
    formData.append('token', data.token);
    formData.append('to_group_token', data.to_group_token);
    formData.append('text', data.text);
    if (data.reply_to_id && data.reply_to_id !== undefined) {
      formData.append('reply_to_id', data.reply_to_id.toString());
    }
    if (data.attachment && data.attachment !== -1) {
      const { uri, type, name } = data.attachment;
      formData.append('attachment', {
        uri,
        type: type === 'image' ? type + '/' + uri.split('.').pop()! : type,
        name: name || 'file'
      } as unknown as Blob);
    }

    return request.postForm<PostSendMessageReturn>(API.SEND_GROUP_MESSAGE, formData);
  },
  groupMessagesReceived: (data: PostGroupMessagesReceivedOrRead) =>
    request.postForm<ResponseType>(API.GROUP_MESSAGES_RECEIVED, data),
  groupMessagesRead: (data: PostGroupMessagesReceivedOrRead) =>
    request.postForm<ResponseType>(API.GROUP_MESSAGES_READ, data),
  reactToGroupMessage: (data: PostReactToGroupMessage) =>
    request.postForm<ResponseType>(API.REACT_TO_GROUP_MESSAGE, data),
  unreactToGroupMessage: (data: PostUnreactToGroupMessage) =>
    request.postForm<ResponseType>(API.UNREACT_TO_GROUP_MESSAGE, data)
};