var alexa = require("alexa-app");
var app = new alexa.app("sample");
 
app.intent("number", {
    "slots": { "number": "AMAZON.NUMBER" },
    "utterances": ["say the number {-|number}"]
  },
  function(request, response) {
    var number = request.slot("number");
    response.say("You asked for the number " + number);
  }
);
 
// connect the alexa-app to AWS Lambda
exports.handler = app.lambda();

var express = require("express");
var alexa = require("alexa-app");
var express_app = express();
 
var app = new alexa.app("sample");
 
app.intent("number", {
    "slots": { "number": "AMAZON.NUMBER" },
    "utterances": ["say the number {-|number}"]
  },
  function(request, response) {
    var number = request.slot("number");
    response.say("You asked for the number " + number);
  }
);
 
// setup the alexa app and attach it to express before anything else
app.express({ expressApp: express_app });
 
// now POST calls to /sample in express will be handled by the app.request() function
// GET calls will not be handled
 
// from here on, you can setup any other express routes or middleware as normal

// return the type of request received (LaunchRequest, IntentRequest, SessionEndedRequest)
String request.type()
 
// return the value passed in for a given slot name
String request.slot("slotName")
 
// return the Slot object
Slot request.slots["slotName"]
 
// return the intent's confirmationStatus
String request.confirmationStatus
 
// check if the intent is confirmed
Boolean request.isConfirmed()
 
// return the Dialog object
Dialog request.getDialog()
 
// check if you can use session (read or write)
Boolean request.hasSession()
 
// return the session object
Session request.getSession()
 
// return the request context
request.context
 
// the raw request JSON object
request.data

// tell Alexa to say something; multiple calls to say() will be appended to each other
// all text output is treated as SSML
response.say(String phrase)
 
// empty the response text
response.clear()
 
// tell Alexa to re-prompt the user for a response, if it didn't hear anything valid
response.reprompt(String phrase)
 
// return a card to the user's Alexa app
// for Object definition @see https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference#card-object
// skill supports card(String title, String content) for backwards compat of type "Simple"
response.card(Object card)
 
// return a card instructing the user how to link their account to the skill
// this internally sets the card response
response.linkAccount()
 
// play audio stream (send AudioPlayer.Play directive) @see https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/custom-audioplayer-interface-reference#play-directive
// skill supports stream(String url, String token, String expectedPreviousToken, Integer offsetInMilliseconds)
response.audioPlayerPlayStream(String playBehavior, Object stream)
 
// stop playing audio stream (send AudioPlayer.Stop directive)
response.audioPlayerStop()
 
// clear audio player queue (send AudioPlayer.ClearQueue directive)
// clearBehavior is "CLEAR_ALL" by default
response.audioPlayerClearQueue([ String clearBehavior ])
 
// tell Alexa whether the user's session is over; sessions end by default
// you can optionally pass a reprompt message
response.shouldEndSession(boolean end [, String reprompt] )
 
// send the response to the Alexa device (success) immediately
// this returns a promise that you must return to continue the
// promise chain. Calling this is optional in most cases as it
// will be called automatically when the handler promise chain
// resolves, but you can call it and return its value in the
// chain to send the response immediately. You can also use it
// to send a response from `post` after failure.
async response.send()
 
// trigger a response failure
// the internal promise containing the response will be rejected, and should be handled by the calling environment
// instead of the Alexa response being returned, the failure message will be passed
// similar to `response.send()`, you must return the value returned from this call to continue the promise chain
// this is equivalent to calling `throw message` in handlers
// *NOTE:* this does not generate a response compatible with Alexa, so when calling it explicitly you may want to handle the response with `.error` or `.post`
async response.fail(String message)
 
// calls to response can be chained together
return response.say("OK").send()

var Speech = require('ssml-builder');
 
var speech = new Speech()
  .say('Hello')
  .pause('1s')
  .say('fellow Alexa developers')
  .pause('500ms')
  .say('Testing phone numbers')
  .sayAs({
    word: "+1-234-567-8900",
    interpret: "telephone"
  });
 
// change 'true' to 'false' if you want to include the surrounding <speak/> tag
var speechOutput = speech.ssml(true);
response.say(speechOutput);

var AmazonSpeech = require('ssml-builder/amazon_speech');
 
var speech = new AmazonSpeech()
  .say('Hello')
  .pause('1s')
  .whisper('I can see you when you are sleeping')
  .pause('500ms')
  .say('Is your phone number still')
  .sayAs({
    word: "+1-234-567-8900",
    interpret: "telephone"
  });
 
var speechOutput = speech.ssml();
response.say(speechOutput);

// check if you can use session (read or write)
Boolean request.hasSession()
 
// get the session object
var session = request.getSession()
 
// set a session variable
// by defailt, Alexa only persists session variables to the next request
// the alexa-app module makes session variables persist across multiple requests
// Note that you *must* use `.set` or `.clear` to update
// session properties. Updating properties of `attributeValue`
// that are objects will not persist until `.set` is called
session.set(String attributeName, String attributeValue)
 
// return the value of a session variable
String session.get(String attributeName)
 
// session details, as passed by Amazon in the request
// for Object definition @see https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference#session-object
session.details = { ... }

// get the slot object
var slot = request.slots["slotName"]
 
// return the slot's name
String slot.name
 
// return the slot's value
String slot.value
 
// return the slot's confirmationStatus
String slot.confirmationStatus
 
// check if the slot is confirmed
Boolean slot.isConfirmed()

app.launch(function(request, response) {
  response.say("Hello World");
  response.card("Hello World", "This is an example card");
});

app.intent("live", {
    "dialog": {
      type: "delegate",
    },
    "slots": {
      "city": "AMAZON.US_CITY"
    },
    "utterances": [
      "in {-|city}"
    ]
  },
  function(request, response) {
    response.say("You live in " + request.slot("city"));
  }
);
 
app.intent("vacation", function(request, response) {
  response.say("You're now on vacation.");
});

app.intent("AMAZON.HelpIntent", {
    "slots": {},
    "utterances": []
  },
  function(request, response) {
    var helpOutput = "You can say 'some statement' or ask 'some question'. You can also say stop or exit to quit.";
    var reprompt = "What would you like to do?";
    // AMAZON.HelpIntent must leave session open -> .shouldEndSession(false)
    response.say(helpOutput).reprompt(reprompt).shouldEndSession(false);
  }
);
 
app.intent("AMAZON.StopIntent", {
    "slots": {},
    "utterances": []
  }, function(request, response) {
    var stopOutput = "Don't You Worry. I'll be back.";
    response.say(stopOutput);
  }
);
 
app.intent("AMAZON.CancelIntent", {
    "slots": {},
    "utterances": []
  }, function(request, response) {
    var cancelOutput = "No problem. Request cancelled.";
    response.say(cancelOutput);
  }
);

app.displayElementSelected(function(request, response) {
  // The request object selectedElementToken will be populated with the token that was registered
  // the element in the display directive. To get the token associated with the directive itself,
  // it is populated on the request.context.Display.token property.
  handleRequestForTouchEvent(request.selectedElementToken)
})

app.sessionEnded(function(request, response) {
  // cleanup the user's server-side session
  logout(request.userId);
  // no response required
});

app.audioPlayer("PlaybackNearlyFinished", function(request, response) {
  // immediate response
  var stream = {
    "url": "https://next-song-url",
    "token": "some_token",
    "expectedPreviousToken": "some_previous_token",
    "offsetInMilliseconds": 0
  };
  response.audioPlayerPlayStream("ENQUEUE", stream);
});

app.audioPlayer("PlaybackFinished", function(request, response) {
  // async response
  return getNextSongFromDBAsync()
  .then(function(url, token) {
    var stream = {
      "url": url,
      "token": token,
      "expectedPreviousToken": "some_previous_token",
      "offsetInMilliseconds": 0
    };
    response.audioPlayerPlayStream("ENQUEUE", stream);
  });
});

app.playbackController('NextCommandIssued', (request, response) => {
  var stream = {
    "url": "https://next-song-url",
    "token": "some_token",
    "expectedPreviousToken": "some_previous_token",
    "offsetInMilliseconds": 0
  };
  response.audioPlayerPlayStream("REPLACE_ALL", stream);
});

app.pre = function(request, response, type) {
  if (request.applicationId != "amzn1.echo-sdk-ams.app.000000-d0ed-0000-ad00-000000d00ebe") {
    // fail ungracefully
    throw "Invalid applicationId";
    // `return response.fail("Invalid applicationId")` will also work
  }
};
 
// Asynchronous
app.pre = function(request, response, type) {
  return db.getApplicationId().then(function(appId) {
    if (request.applicationId != appId) {
      throw new Error("Invalid applicationId");
    }
  });
};

app.post = function(request, response, type, exception) {
  if (exception) {
    // always turn an exception into a successful response
    return response.clear().say("An error occured: " + exception).send();
  }
};

app.intent("sampleIntent", {
    "slots": {
      "NAME": "AMAZON.US_FIRST_NAME",
      "AGE": "AMAZON.NUMBER"
    },
    "utterances": [
      "my {name is|name's} {NAME} and {I am|I'm} {-|AGE}{ years old|}"
    ]
  },
  function(request, response) { ... }
);

app.intent("sampleIntent", {
    "slots": {
      "CustomSlotName": "CustomSlotType"
    },
    "utterances": [
      "airport {information|status} for {-|CustomSlotName}"
    ]
  },
  function(request, response) { ... }
);

testApp.customSlot("animal", ["cat", "dog"]);

testApp.customSlot("animal", [{
  value: "dog",
  id: "canine",
  synonyms: ["doggo", "pupper", "woofmeister"]
}]);

app.dictionary = {"colors":["red","green","blue"]};
...
"my favorite color is {colors|FAVEORITE_COLOR}"
"I like {colors|COLOR}"

// returns a String representation of an Intent Schema JSON object
app.schemas.intent() =>
 
{
  "intents": [{
    "intent": "MyColorIsIntent",
    "slots": [{
      "name": "Color",
      "type": "AMAZON.Color"
    }]
  }]
}
 
app.utterances() =>
 
MyColorIsIntent  my color is {dark brown|Color}
MyColorIsIntent  my color is {green|Color}
MyColorIsIntent  my favorite color is {red|Color}
MyColorIsIntent  my favorite color is {navy blue|Color}
WhatsMyColorIntent whats my color
WhatsMyColorIntent what is my color
WhatsMyColorIntent say my color
WhatsMyColorIntent tell me my color
WhatsMyColorIntent whats my favorite color
WhatsMyColorIntent what is my favorite color
WhatsMyColorIntent say my favorite color
WhatsMyColorIntent tell me my favorite color
WhatsMyColorIntent tell me what my favorite color is

app.schemas.skillBuilder() =>
 
{
  "intents": [{
    "name": "MyColorIsIntent",
    "samples": [
      "my color is {dark brown|Color}",
      "my color is {green|Color}",
      "my favorite color is {red|Color}",
      "my favorite color is {navy blue|Color}"
    ],
    "slots": [{
      "name": "Color",
      "type": "AMAZON.Color",
      "samples": []
    }]
  }],
  "types": [{
    "name": "MyCustomColor",
    "values": [{
      "id": null,
      "name": {
        "value": "aquamarine",
        "synonyms": ["aqua", "seafoam", "teal"]
      }
    }]
  }];
}

response.card({
  type: "Simple",
  title: "My Cool Card", // this is not required for type Simple
  content: "This is the\ncontent of my card"
});

response.card({
  type: "Standard",
  title: "My Cool Card", // this is not required for type Simple or Standard
  text: "Your ride is on the way to 123 Main Street!\nEstimated cost for this ride: $25",
  image: { // image is optional
    smallImageUrl: "https://carfu.com/resources/card-images/race-car-small.png", // required
    largeImageUrl: "https://carfu.com/resources/card-images/race-car-large.png"
  }
});

response.card({
  type: "AskForPermissionsConsent",
  permissions: [ "read::alexa:device:all:address" ] // full address
});

app.intent("sampleIntent", {
    "dialog": {
      type: "delegate"
    },
    "slots": { ... },
    "utterances": [ ... ],
  },
  function(request, response) { ... }
);

// return the Dialog object
Dialog request.getDialog()
 
// return the intent's dialogState
String request.dialogState
 
// check if the intent's dialog is STARTED
Boolean dialog.isStarted()
 
// check if the intent's dialog is IN_PROGRESS
Boolean dialog.isInProgress()
 
// check if the intent's dialog is COMPLETED
Boolean dialog.isCompleted()

app.error = function(exception, request, response) {
  response.say("Sorry, something bad happened");
};

app.error = function(exception, request, response) {
  console.error(exception);
  throw exception;
};

app.intent("checkStatus", function(request, response) {
  // `getAsync` returns a Promise in this example. When
  // returning a Promise, the response is sent after it
  // resolves. If rejected, it is treated as an error.
  return http.getAsync("http://server.com/status.html").then(function (rc) {
    response.say(rc.statusText);
  });
});

app.intent("checkStatus", function(request, response) {
  if (currentStatus == "bad") {
    return response.fail("bad status");
  }
  else if (currentStatus == "good") {
    response.say("good status");
    return response.send();
  }
 
  return http.getAsync("http://server.com/status.html").then(function (rc) {
    if (rc.body == "bad") {
      throw "bad status";
    }
    response.say("good status");
    // return `response.send` to continue the promise chain
    return response.send();
  });
});

app.messages.NO_INTENT_FOUND = "Why you called dat intent? I don't know bout dat";

app.launch(function(request, response) {
  request.getSession().set("number", 42);
  response.say("Would you like to know the number?");
  response.shouldEndSession(false);
});
 
app.intent("tellme", function(request, response) {
  var session = request.getSession();
  response.say("The number is " + session.get("number"));
  // clear only the 'number' attribute from the session
  session.clear("number");
});
 
// the session variables can be entirely cleared, or cleared by key
app.intent("clear", function(request, response) {
  var session = request.getSession();
  session.clear(); // or: session.clear("key") to clear a single value
  response.say("Session cleared!");
});

var app = new alexa.app("test");
app.persistentSession = false;

var app = new alexa.app("hello", "myEndpointName");