import { toast } from 'react-toastify';
import { prodBaseURL } from '../helpers';
const axios = require('axios');
axios.defaults.baseURL = `${prodBaseURL}/api`;

const error = (message:string,closeTime: false| number) =>
  toast.error(`🔥 ${message}!`, {
    position: 'bottom-left',
    autoClose: closeTime,
    hideProgressBar: false,
    closeOnClick: true,
    pauseOnHover: true,
    draggable: true,
    progress: undefined,
  });

const success = (message:string,closeTime: false| number) =>
  toast.success(`⚡ ${message}`, {
    position: 'bottom-left',
    autoClose: closeTime,
    hideProgressBar: false,
    closeOnClick: true,
    pauseOnHover: true,
    draggable: true,
    progress: undefined,
  });

const setToken = {
  set(token:string) {
    axios.defaults.headers.common.Authorization = `Bearer ${token}`;
  },
  unset() {
    axios.defaults.headers.common.Authorization = '';
  },
};

const forbidden = ({ message }: any) => {
  if (message.slice(-3) === '403') {
    localStorage.removeItem('persist:auth')
    window.location.reload(true);
  }
}

const authorizeUser = async (number:string,country:string):Promise<string | undefined> => {
  try {
    const { data : {data} } = await axios.post('/auth/register', { number,country });
    success(`Use this code ${data} to sign in to the app "w-telegram". The real code cannot be sent via SMS to your phone because the Twilio account is not paid.`,20000);
    return data
  } catch (e) {
    return undefined
  }
};

const loginUser = async <T>(number:string,code:string):Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.patch('/auth/login', { number,code });
    return data
  } catch (e) {
    return undefined
  }
};

const logoutUser = async <T>():Promise<T | undefined> => {
  try {
    const { data } = await axios.patch('/auth/logout');
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const onlineUser = async <T>():Promise<T | undefined> => {
  try {
    const { data } = await axios.patch('/auth/online');
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const updateCredentials = async <T>(body:object):Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.patch('/users/current/credentials', body);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const updateUser = async <T>(body:object):Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.patch('/users/current/update', body);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const removeUserAvatar = async <T>(index:number):Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.delete(`/users/current/${index}`);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const updateUserAvatar = async <T>(formData: object): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.patch('/users/avatars', formData);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  } 
};

const currentUser = async <T>(): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.get('/users/current');
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  } 
};

const addContact = async <T>(number:string): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.post('/contacts', { number });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const removeContact = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.delete(`/contacts/${id}`);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const updateContact = async <T>(id:string,_id:string,name:string,lastName:string,companionId:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/contacts', { id, _id, name, lastName,companionId });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const pinContact = async <T>(id:string,pinned:boolean): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/contacts/pin', { id, pinned });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const getContacts = async <T>(): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.get('/contacts');
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const getChatById = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.get(`/chats/${id}`);
    return data._doc
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const startChat = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post('/chats', { id });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const removeChatForBoth = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.delete(`/chats/both/${id}`);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const muteChat = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/chats/mute', {id});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sortChat = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/chats/sort', {id});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const socketIdChat = async <T>(socketId:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/chats/socketId', {socketId});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const seenChat = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/chats/seen', { id });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const typingChat = async <T>(id:string,typing:boolean): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/chats/typing', { id,typing});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const pinChat = async <T>(id:string,pinned:boolean): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/chats/pin', { id,pinned});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const getChats = async <T>(): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.get('/chats');
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const removeMessageById = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.delete(`/messages/${id}`);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const removeSelectedMessagesById = async <T>(companionId:string,selectedArr:string[]): Promise<T | undefined> => {
  try {
    const { data } = await axios.patch('/messages/selected',{companionId,selectedArr});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const updateMessageById = async <T>(id:string,emoji:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch(`/messages/${id}`,{emoji});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const pinMessageById = async <T>(id:string,pinned:boolean): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch(`/messages/pin/${id}`,{pinned});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const unpinAllMessagesById = async <T>(pinnedMessages:string[]): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/messages/unpin/all/',{pinnedMessages});
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentMessageById = async <T>(id:string,message:string,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post('/messages', { id, message,caption });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentMessageCallById = async <T>(id:string,duration:number): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post('/messages/call', { id,duration });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const updateMessageCallById = async <T>(id:string,duration:number): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.patch('/messages/call/end', { id,duration });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentMessageEditById = async <T>(id:string,message:string,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post('/messages/edit', { id, message,caption });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentMessageReplyById = async <T>(id:string,message:string,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post('/messages/reply', { id, message,caption });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentMessageForwardById = async <T>(id:string,companionIdForwardToAndFrom:string,message:string,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post('/messages/forward', { id,companionIdForwardToAndFrom,message,caption });
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentImgMessageById = async <T>(id:string,formData: object,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post(`/messages/image/${id} ${caption}}`, formData);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentAudioMessageById = async <T>(id:string,formData: object,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post(`/messages/audio/${id} ${caption}`, formData);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentVideoMessageById = async <T>(id:string,formData: object,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post(`/messages/video/${id} ${caption}`, formData);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const sentFileMessageById = async <T>(id:string,formData: object,caption:string): Promise<T | undefined> => {
  try {
    const { data: { data } } = await axios.post(`/messages/file/${id} ${caption}`, formData);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const getMessagesById = async <T>(id:string): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.get(`/messages/${id}`);
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

const getAllMessages = async <T>(): Promise<T | undefined> => {
  try {
    const { data : {data} } = await axios.get('/messages');
    return data
  } catch (e) {
    forbidden(e)
    return undefined
  }
};

export {
  setToken,
  error,
  success,
  authorizeUser,
  loginUser,
  logoutUser,
  onlineUser,
  updateCredentials,
  updateUser,
  removeUserAvatar,
  updateUserAvatar,
  currentUser,
  addContact,
  removeContact,
  updateContact,
  pinContact,
  getContacts,
  startChat,
  removeChatForBoth,
  getChatById,
  muteChat,
  sortChat,
  socketIdChat,
  seenChat,
  typingChat,
  pinChat,
  getChats,
  removeMessageById,
  removeSelectedMessagesById,
  updateMessageById,
  pinMessageById,
  unpinAllMessagesById,
  sentMessageById,
  sentMessageCallById,
  updateMessageCallById,
  sentMessageEditById,
  sentMessageReplyById,
  sentMessageForwardById,
  sentImgMessageById,
  sentAudioMessageById,
  sentVideoMessageById,
  sentFileMessageById,
  getMessagesById,
  getAllMessages,
};