// This function is the endpoint's request handler.
// NOTE: MAKE THIS async TO SAVE HEADACHES
exports = async function({ query, headers, body}, response) {
    const db = context.services.get("MY_LINKED_DATA_SOURCE").db("MY_DB_NAME");
    // we're going to hash the user's phone number because
    // we don't want the risk of storing that personal info

    const { createHash } = require('crypto');

    async function getOwnerObj(db, hashedPhoneNumber) {
      const collection = db.collection("NAME_OF_COLLECTION_WITH_PHONE_HASH");
      // below: phoneHash & ownerId are field names within our data
      // your names may be different
      const query = {"phoneHash": hashedPhoneNumber};
      const projection = {"ownerId" : 1};

      // Use findOne() to retrieve a single document from the collection
      return await collection.findOne(query, projection)
    }

    function cleanPhoneNumber(phoneNumber){
      // our app is US only so the phone numbers will start with
      // the US country code: +1
      // you may not want this, or may need a different regex
      return phoneNumber.replace(/^\+\d/, "");
    }

    function phoneHash(phoneNumber) {
      // it's a good idea to add in some "salt" here.
      return createHash('sha256').update(cleanPhoneNumber(phoneNumber)).digest('hex');
    }

    // --------------------------------------
    // BEGIN procedural code
    //
    // Raw request body
    // This is a binary object that can be accessed as a string using .text()
    const reqBody = body.text();

    // For a full list of parameters they send
    // check out https://www.twilio.com/docs/voice/twiml#request-parameters
    // We only care about who the message came from, and what the message was.
    const { From, Body } = JSON.parse(reqBody);

    // Set up the default data you'll return
    // I've decided to go with HTTP Status Codes, because they've already
    // got something to address most situations.
    var responseData = {
        "status": 200, // 200 if everything goes as expected
        "message": null // the message we'll return to the user
    };

    // hash the phone number, find a matching entry,
    // return it.
    // NOTE: we have to await the response, even though we already
    // awaited the response inside the functions we're calling.
    const ownerObj = await getOwnerObj(db, phoneHash(From));

    if (ownerObj != null) {
        // OK we have a user. Yay.

        // insert your message processing logic here.
        // if anything goes wrong, change the status code
        // in responseData
        // the message will be whatever message you want to return
        // to the user. Note that outbound texts are VERY rate limited
        // in twilio so, only respond with a message when you need to.

        responseData.message="it worked and i found a user";

    } else {
        responseData.status = 403;
        responseData.message = "No registered user with that phone number.";
    }
    return responseData;

};

const axios = require('axios');

exports.handler = async (context, event, callback) => {
  // Create a new message response object
  const twiml = new Twilio.twiml.MessagingResponse();

  //twiml.message("bogus");
  //return callback(null, twiml);

  const instance = axios.create({
    baseURL: "THE DOMAIN NAME OF YOUR ATLAS FUNCTION'S URL",
    headers: { 'X-Custom-Header': 'Twilio' ,
               'Content-Type': 'application/json',
    },
  });

  try {
    // axios#post(url[, data[, config]])
    // const {status, message} = await instance.post(
    const mongoResponse = await instance.post(
      "EVERYTHING AFTER THE DOMAIN NAME OF YOUR ATLAS FUNCTION'S URL",
      {
        "From": event.From,
        "Body": event.Body
      }

    );

    if (mongoResponse.status == 200){
      // remember, or response is in the .data portion of the
      // big wrapper MongoDB Atlas put around it.
      const myStatus = mongoResponse.data.status;
      const message = mongoResponse.data.message;

      // maybe change something if myStatus != 200
      twiml.message(message);

    } else {
      // note: this is MONGO's status, not yours
      twiml.message(mongoResponse.statusText);
    }


    return callback(null, twiml);
  } catch (error) {
    // As always with async functions, you need to be sure to handle errors
    console.error(error);
    // Add a message to the response to let the user know that something went wrong
    twiml.message(`We received your message, but something went wrong 😭 ${error}`);
    return callback(error);
  }
};