// send ephemeral event
conversation
  .sendEphemeralEvent({ state: "INVITED" })
  .then((event) => {
    console.log(event)
  });

// iterate through conversations
application
  .getConversations({ state: "INVITED" })
  .then((conversations_page) => {
    conversations_page.items.forEach(conversation => {
      render(conversation);
    })
  });

rtc.createSession(token).then((application) => {
  console.log(application);
}).catch((error) => {
  console.log(error);
});

rtc.deleteSession().then((response) => {
  console.log(response);
}).catch((error) => {
  console.log(error);
});

rtc.connectivityReport(token, {
  dcListCallback: (dcList) => {...dcList, additionalDc}
}).then((report) => {
  console.log(report);
}).catch((error) => {
  console.log(error);
});

rtc.checkMediaServers('token', 'nexmo-api-url','dc').then((responseArray) => {
 console.log(responseArray);
}).catch((error) => {
  console.log(error);
});

rtc.checkMediaServers('nexmo-api-url','dc').then((responseArray) => {
	console.log(responseArray);
}).catch((error) => {
  console.log(error);
});

rtc.checkMediaConnectivity('ip-address','1').then((response) => {
  console.log(response);
}).catch((error) => {
	console.log(error);
});

rtc.connectivityReport({
  dcListCallback: (dcList) => {...dcList, additionalDc}
}).then((report) => {
  console.log(report);
}).catch((error) => {
  console.log(error);
});

messageEvent.seen().then(() => {
  console.log(`Seen message with id ${messageEvent.id}`);
}).catch((error) => {
  console.log(error);
});

conversation.on("message:delivered", (member, event) => {
  console.log(`Message with id ${event.id} delivered to ${member.name}`);
});

rtc.connectivityReport().then((report) => {
  console.log(report);
}).catch((error) => {
  console.log(error);
});

const params = {
  quality_ratio : "90",
  medium_size_ratio: "40",
  thumbnail_size_ratio: "20"
};

conversation.uploadImage(fileInput.files[0], params).then((uploadImageRequest) => {
  uploadImageRequest.onprogress = (e) => {
    console.log("Image request progress: ", e);
    console.log("Image progress: " + e.loaded + "/" + e.total);
  };
  uploadImageRequest.onabort = (e) => {
    console.log("Image request aborted: ", e);
    console.log("Image: " + e.type);
  };
  uploadImageRequest.onloadend = (e) => {
    console.log("Image request successful: ", e);
    console.log("Image: " + e.type);
  };
  uploadImageRequest.onreadystatechange = () => {
    if (uploadImageRequest.readyState === 4 && uploadImageRequest.status === 200) {
      const representations = JSON.parse(uploadImageRequest.responseText);
      console.log("Original image url: ", representations.original.url);
      console.log("Medium image url: ", representations.medium.url);
      console.log("Thumbnail image url: ", representations.thumbnail.url);
    }
  };
}).catch((error) => {
  console.error("error uploading the image ", error);
});

conversation.sendMessage({
  "message_type": "text",
  "text": "Hi Vonage!"
}).then((event) => {
  console.log("message was sent", event);
}).catch((error)=>{
  console.error("error sending the message ", error);
});

conversation.sendMessage({
  "message_type": "image",
  "image": {
    "url": "https://example.com/image.jpg"
  }
})
.then((event) => {
  console.log("message was sent", event);
}).catch((error)=>{
  console.error("error sending the message ", error);
});

conversation.on("message", (member, messageEvent) => {
  console.log(messageEvent);
});

conversation.sendMessage({ "message_type": "text", "text": "Hi Vonage!" }).then((event) => {
  console.log("message was sent", event);
}).catch((error)=>{
  console.error("error sending the message ", error);
});

conversation.uploadImage(imageFile).then((imageRequest) => {
  imageRequest.onreadystatechange = () => {
    if (imageRequest.readyState === 4 && imageRequest.status === 200) {
      try {
        const { original, medium, thumbnail } = JSON.parse(imageRequest.responseText);
        const message = {
          message_type: 'image',
          image: {
            url: original.url ?? medium.url ?? thumbnail.url
          }
        }
        return conversation.sendMessage(message);
      } catch (error) {
        console.error("error sending the message ", error);
      }
    }
    if (imageRequest.status !== 200) {
      console.error("error uploading the image");
    }
  };
  return imageRequest;
})
.catch((error) => {
  console.error("error uploading the image ", error);
});

application.getUserSessions({ user_id: "USR-id", page_size: 20 }).then((user_sessions_page) => {
  user_sessions_page.items.forEach(user_session => {
    render(user_session)
  })
}).catch((error) => {
  console.error(error);
});

application.reconnectCall(
  "conversation_id",
  "rtc_id",
  { audioConstraints: { deviceId: "device_id" } }
).then((nxmCall) => {
  console.log(nxmCall);
}).catch((error) => {
  console.error(error);
});

application.reconnectCall("conversation_id", "rtc_id").then((nxmCall) => {
  console.log(nxmCall);
}).catch((error) => {
  console.error(error);
});

conversation.media.enable({ reconnectRtcId: "UUID" }).then((stream) => {
  console.log(stream)
}).catch((error) => {
  console.error("error renabling media", error);
});

application.callServer("<phone_number>", "phone", { field1: "test" }).then((nxmCall) => {
  console.log(nxmCall);
}).catch((error) => {
  console.error(error);
});

conversation.on("any:event", ({memberId, userId, userName, displayName, imageUrl, customData}, event) => {});

conversation.getMembers().then((members_page) => {
  members_page.items.forEach(member => {
    render(member);
  })
}).catch((error) => {
  console.error("error getting the members ", error);
});

conversation.getMyMember().then((member) => {
  render(member);
}).catch((error) => {
  console.error("error getting my member", error);
});

conversation.getMember("MEM-id").then((member) => {
  render(member);
}).catch((error) => {
  console.error("error getting member", error);
});

"acl": {
  "paths": {
    ...
    "/*/legs/**": {}
  }
}

  application.on('system:error:expired-token', 'NXM-errors', () => {
    console.log('Token Expired');
  });

new NexmoClient({
  debug: 'info'
})

// iterate through conversations
application
  .getConversations({ page_size: 20 })
  .then((conversations_page) => {
    conversations_page.items.forEach(conversation => {
      render(conversation);
    })
  });

// iterate through events
conversation
  .getEvents({ event_type: `member:*` })
  .then((events_page) => {
    events_page.items.forEach(event => {
      render(event);
    })
  });

//sending a custom event type to a conversation
conversation
  .sendCustomEvent({type: `my_custom_event`, body: { enabled: true }})
  .then((custom_event) => {
    console.log(event.body);
  });

//listening for a custom event type
conversation.on(`my_custom_event`, (from, event) => {
  console.log(event.body);
});

new NexmoClient({
  conversations_page_config: {
    page_size: 25,
    order: 'asc'
    cursor: 'abc'
  },
  events_page_config: {
    page_size: 50,
    event_type: `member:*`
  }
})

application.conversations_page_last
  .getNext((conversations_page) => {
    conversations_page.items.forEach(conversation => {
      render(conversation)
    })
  })

conversation.events_page_last
  .getPrev((events_page) => {
    events_page.items.forEach(event => {
      render(event)
    })
  })

// IP-IP call scenario
application
  .callServer('username', 'app')
  .then((nxmCall) => {
    // console.log(nxmCall);
  });

// IP-PSTN call scenario
application
  .callServer('07400000000')
  .then((nxmCall) => {
    // console.log(nxmCall);
  });

/**
 * Perform a GET network request directly to CS
 *
 * @param {string} url the request url to CS
 * @param {string} data_type the type of data expected back from the request (events, conversations, users)
 * @param {object} [params] network request params
 * @param {string} [params.cursor] cursor parameter to access the next or previous page of a data set
 * @param {number} [params.page_size] the number of resources returned in a single request list
 * @param {string} [params.order] 'asc' or 'desc' ordering of resources (usually based on creation time)
 * @param {string} [params.event_type] the type of event used to filter event requests ('member:joined', 'audio:dtmf', etc)
 *
 * @returns {Promise<XMLHttpRequest.response>} the XMLHttpRequest.response
 * @static
 * @example <caption>Sending a nexmo GET request</caption>
 */
  nexmoGetRequest(url, data_type, params).then((response) => {
    response.body: {},
    response.cursor: {
        prev: '',
        next: '',
        self: ''
    },
    response.page_size: 10
 });

//listening for member:left with reason
conversation.on('member:left', (member, event) => {
  console.log(event.body.reason);
});

/**
* Reason object format
*
* @param {object} [reason] the reason for kicking out a member
* @param {string} [reason.code] the code of the reason
* @param {string} [reason.text] the description of the reason
*/

conversation.on("member:call:status", (member) => {
   console.log(member.callStatus);
});

/**
  * Conversation listening for leg:status:update events.
  *
  * @event Conversation#leg:status:update
  *
  * @property {Member} member - the member whose leg status changed
  * @property {Event} event - leg:status:update event
  * @param {string} event.cid - the conversation id
  * @param {string} event.body.leg_id - the conversation leg id
  * @param {string} event.body.type - the conversation leg type (phone or app)
  * @param {string} event.body.status - the conversation member leg status
  * @param {Array} event.body.statusHistory - array of previous leg statuses
*/
conversation.on("leg:status:update", (member, event) {
  console.log(member, event);
});

conversation.on(<member_event>, (member, event) {
  console.log(event);
  // member_id: <member_id>,
  // conversation_id: <conversation_id>,
  // ...
  // channel: {
  //  to: {
  //    type: app
  //  },
  //  type: app,
  //  leg_ids: [<leg_id>]
  //  legs : [{ leg_id: <leg_id>, status: <leg_status>}],
  //  leg_settings: {},
  // },
  // state: <state>,
  // leg_ids: []
});

 * Send DTMF in a conversation
 *
 * @param {string} digits - the DTMF digit(s) to send
 * @returns {Promise<Event>}

 conversation.media.sendDTMF('digits')

conversation.on("audio:dtmf",(from, event)=>{
  event.digit // the dtmf digit(s) received
  event.from //id of the user who sent the dtmf
  event.timestamp //timestamp of the event
  event.cid // conversation id the event was sent to
  event.body // additional context about the dtmf
});

 conversation.media.enable({
    'audioConstraints': audioConstraints
 })

  * Replaces the stream's audio tracks currently being used as the sender's sources with a new one with new audio constraints
  * @param {object} constraints - audio constraints
  * @returns {Promise<MediaStream>} - Returns the new stream with the updated audio constraints.
  * @example
  * conversation.media.updateAudioConstraints({'autoGainControl': true})
  **/

  conversation.media.updateAudioConstraints(audioConstraints)
 })

media.enable({
  autoPlayAudio: true | false
})

 * @class ConversationClient
 *
 * @param {object} param.log_reporter configure log reports for bugsnag tool
 * @param {Boolean} param.log_reporter.enabled=false
 * @param {string} param.log_reporter.bugsnag_key your bugsnag api key / defaults to Vonage api key

member.on("media:connection:fail",(connection_details)=>{
  connection_details.rtc_id // my member's call id / leg id
  connection_details.remote_member_id // the id of the Member the stream belongs to
  connection_details.connection_event: // the connection fail event
  connection_details.type // the type of the connection (video or screenshare)
  connection_details.streamIndex // the streamIndex of the specific stream
});

* @event Member#media:connection:fail
*
* @property {number} payload.rtc_id the rtc_id / leg_id
* @property {string} payload.remote_member_id the id of the Member the stream belongs to
* @property {event} payload.connection_event the connection fail event

type: 'member:media',
  from: member.member_id,
  conversation_id: member.conversation_id,
  body: {
    media: member.media,
    channel: member.channel
  }

type: 'member:invited',
  body: {
    media: {
      audio_settings: {
        enabled: false,
        earmuffed: false,
        muted: false
      }
    }
  }

 * @event Member#media:stream:on
 *
 * @property {number} payload.streamIndex the index number of this stream
 * @property {number} [payload.rtc_id] the rtc_id / leg_id
 * @property {string} [payload.remote_member_id] the id of the Member the stream belongs to
 * @property {string} [payload.name] the stream's display name
 * @property {MediaStream} payload.stream the stream that is activated
 * @property {boolean} [payload.video_mute] if the video is hidden
 * @property {boolean} [payload.audio_mute] if the audio is muted